1 //===------------------------- dynamic_cast3.cpp --------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include <cassert>
10 #include "support/timer.h"
11
12 // This test explicitly tests dynamic cast with types that have inaccessible
13 // bases.
14 #if defined(__clang__)
15 #pragma clang diagnostic ignored "-Winaccessible-base"
16 #endif
17
18 /*
19
20 A1 A2 A3
21
22 */
23
24 namespace t1
25 {
26
27 struct A1
28 {
29 char _[43981];
~A1t1::A130 virtual ~A1() {}
31
getA1t1::A132 A1* getA1() {return this;}
33 };
34
35 struct A2
36 {
37 char _[34981];
~A2t1::A238 virtual ~A2() {}
39
getA2t1::A240 A2* getA2() {return this;}
41 };
42
43 struct A3
44 {
45 char _[93481];
~A3t1::A346 virtual ~A3() {}
47
getA3t1::A348 A3* getA3() {return this;}
49 };
50
test()51 void test()
52 {
53 A1 a1;
54 A2 a2;
55 A3 a3;
56 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
57 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
58 assert(dynamic_cast<A1*>(a3.getA3()) == 0);
59 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
60 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
61 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
62 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
63 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
64 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
65 }
66
67 } // t1
68
69 /*
70
71 A1 A2
72 |
73 A3
74
75 */
76
77 namespace t2
78 {
79
80 struct A1
81 {
82 char _[43981];
~A1t2::A183 virtual ~A1() {}
84
getA1t2::A185 A1* getA1() {return this;}
86 };
87
88 struct A2
89 {
90 char _[34981];
~A2t2::A291 virtual ~A2() {}
92
getA2t2::A293 A2* getA2() {return this;}
94 };
95
96 struct A3
97 : public A1
98 {
99 char _[93481];
~A3t2::A3100 virtual ~A3() {}
101
getA3t2::A3102 A3* getA3() {return this;}
103 };
104
test()105 void test()
106 {
107 A1 a1;
108 A2 a2;
109 A3 a3;
110 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
111 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
112 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
113 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
114
115 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
116 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
117 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
118 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
119
120 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
121 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
122 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
123 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
124 }
125
126 } // t2
127
128 namespace t3
129 {
130
131 struct A1
132 {
133 char _[43981];
~A1t3::A1134 virtual ~A1() {}
135
getA1t3::A1136 A1* getA1() {return this;}
137 };
138
139 struct A2
140 {
141 char _[34981];
~A2t3::A2142 virtual ~A2() {}
143
getA2t3::A2144 A2* getA2() {return this;}
145 };
146
147 struct A3
148 : public virtual A1
149 {
150 char _[93481];
~A3t3::A3151 virtual ~A3() {}
152
getA3t3::A3153 A3* getA3() {return this;}
154 };
155
test()156 void test()
157 {
158 A1 a1;
159 A2 a2;
160 A3 a3;
161 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
162 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
163 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
164 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
165
166 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
167 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
168 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
169 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
170
171 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
172 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
173 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
174 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
175 }
176
177 } // t3
178
179 namespace t4
180 {
181
182 struct A1
183 {
184 char _[43981];
~A1t4::A1185 virtual ~A1() {}
186
getA1t4::A1187 A1* getA1() {return this;}
188 };
189
190 struct A2
191 {
192 char _[34981];
~A2t4::A2193 virtual ~A2() {}
194
getA2t4::A2195 A2* getA2() {return this;}
196 };
197
198 struct A3
199 : private A1
200 {
201 char _[93481];
~A3t4::A3202 virtual ~A3() {}
203
getA1t4::A3204 A1* getA1() {return this;}
getA3t4::A3205 A3* getA3() {return this;}
206 };
207
test()208 void test()
209 {
210 A1 a1;
211 A2 a2;
212 A3 a3;
213 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
214 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
215 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
216
217 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
218 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
219 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
220 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
221
222 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
223 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
224 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
225 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
226 }
227
228 } // t4
229
230 namespace t5
231 {
232
233 struct A1
234 {
235 char _[43981];
~A1t5::A1236 virtual ~A1() {}
237
getA1t5::A1238 A1* getA1() {return this;}
239 };
240
241 struct A2
242 {
243 char _[34981];
~A2t5::A2244 virtual ~A2() {}
245
getA2t5::A2246 A2* getA2() {return this;}
247 };
248
249 struct A3
250 : private virtual A1
251 {
252 char _[93481];
~A3t5::A3253 virtual ~A3() {}
254
getA1t5::A3255 A1* getA1() {return this;}
getA3t5::A3256 A3* getA3() {return this;}
257 };
258
test()259 void test()
260 {
261 A1 a1;
262 A2 a2;
263 A3 a3;
264 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
265 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
266 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
267
268 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
269 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
270 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
271 assert(dynamic_cast<A2*>(a3.getA3()) == 0);
272
273 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
274 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
275 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
276 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
277 }
278
279 } // t5
280
281 /*
282
283 A1 A2
284 \ /
285 A3
286
287 */
288
289 namespace t6
290 {
291
292 struct A1
293 {
294 char _[43981];
~A1t6::A1295 virtual ~A1() {}
296
getA1t6::A1297 A1* getA1() {return this;}
298 };
299
300 struct A2
301 {
302 char _[34981];
~A2t6::A2303 virtual ~A2() {}
304
getA2t6::A2305 A2* getA2() {return this;}
306 };
307
308 struct A3
309 : public A1,
310 public A2
311 {
312 char _[93481];
~A3t6::A3313 virtual ~A3() {}
314
getA1t6::A3315 A1* getA1() {return this;}
getA2t6::A3316 A2* getA2() {return this;}
getA3t6::A3317 A3* getA3() {return this;}
318 };
319
test()320 void test()
321 {
322 A1 a1;
323 A2 a2;
324 A3 a3;
325 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
326 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
327 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
328 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
329 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
330
331 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
332 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
333 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
334 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
335 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
336
337 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
338 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
339 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
340 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
341 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
342 }
343
344 } // t6
345
346 namespace t7
347 {
348
349 struct A1
350 {
351 char _[43981];
~A1t7::A1352 virtual ~A1() {}
353
getA1t7::A1354 A1* getA1() {return this;}
355 };
356
357 struct A2
358 {
359 char _[34981];
~A2t7::A2360 virtual ~A2() {}
361
getA2t7::A2362 A2* getA2() {return this;}
363 };
364
365 struct A3
366 : public virtual A1,
367 public A2
368 {
369 char _[93481];
~A3t7::A3370 virtual ~A3() {}
371
getA1t7::A3372 A1* getA1() {return this;}
getA2t7::A3373 A2* getA2() {return this;}
getA3t7::A3374 A3* getA3() {return this;}
375 };
376
test()377 void test()
378 {
379 A1 a1;
380 A2 a2;
381 A3 a3;
382 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
383 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
384 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
385 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
386 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
387
388 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
389 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
390 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
391 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
392 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
393
394 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
395 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
396 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
397 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
398 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
399 }
400
401 } // t7
402
403 namespace t8
404 {
405
406 struct A1
407 {
408 char _[43981];
~A1t8::A1409 virtual ~A1() {}
410
getA1t8::A1411 A1* getA1() {return this;}
412 };
413
414 struct A2
415 {
416 char _[34981];
~A2t8::A2417 virtual ~A2() {}
418
getA2t8::A2419 A2* getA2() {return this;}
420 };
421
422 struct A3
423 : private A1,
424 public A2
425 {
426 char _[93481];
~A3t8::A3427 virtual ~A3() {}
428
getA1t8::A3429 A1* getA1() {return this;}
getA2t8::A3430 A2* getA2() {return this;}
getA3t8::A3431 A3* getA3() {return this;}
432 };
433
test()434 void test()
435 {
436 A1 a1;
437 A2 a2;
438 A3 a3;
439 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
440 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
441 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
442 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
443
444 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
445 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
446 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
447 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
448 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
449
450 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
451 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
452 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
453 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
454 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
455 }
456
457 } // t8
458
459 namespace t9
460 {
461
462 struct A1
463 {
464 char _[43981];
~A1t9::A1465 virtual ~A1() {}
466
getA1t9::A1467 A1* getA1() {return this;}
468 };
469
470 struct A2
471 {
472 char _[34981];
~A2t9::A2473 virtual ~A2() {}
474
getA2t9::A2475 A2* getA2() {return this;}
476 };
477
478 struct A3
479 : private virtual A1,
480 public A2
481 {
482 char _[93481];
~A3t9::A3483 virtual ~A3() {}
484
getA1t9::A3485 A1* getA1() {return this;}
getA2t9::A3486 A2* getA2() {return this;}
getA3t9::A3487 A3* getA3() {return this;}
488 };
489
test()490 void test()
491 {
492 A1 a1;
493 A2 a2;
494 A3 a3;
495 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
496 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
497 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
498 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
499
500 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
501 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
502 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
503 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
504 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
505
506 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
507 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
508 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
509 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
510 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
511 }
512
513 } // t9
514
515 namespace t10
516 {
517
518 struct A1
519 {
520 char _[43981];
~A1t10::A1521 virtual ~A1() {}
522
getA1t10::A1523 A1* getA1() {return this;}
524 };
525
526 struct A2
527 {
528 char _[34981];
~A2t10::A2529 virtual ~A2() {}
530
getA2t10::A2531 A2* getA2() {return this;}
532 };
533
534 struct A3
535 : public virtual A1,
536 public virtual A2
537 {
538 char _[93481];
~A3t10::A3539 virtual ~A3() {}
540
getA1t10::A3541 A1* getA1() {return this;}
getA2t10::A3542 A2* getA2() {return this;}
getA3t10::A3543 A3* getA3() {return this;}
544 };
545
test()546 void test()
547 {
548 A1 a1;
549 A2 a2;
550 A3 a3;
551 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
552 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
553 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
554 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
555 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
556
557 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
558 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
559 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
560 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
561 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
562
563 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
564 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
565 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
566 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
567 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
568 }
569
570 } // t10
571
572 namespace t11
573 {
574
575 struct A1
576 {
577 char _[43981];
~A1t11::A1578 virtual ~A1() {}
579
getA1t11::A1580 A1* getA1() {return this;}
581 };
582
583 struct A2
584 {
585 char _[34981];
~A2t11::A2586 virtual ~A2() {}
587
getA2t11::A2588 A2* getA2() {return this;}
589 };
590
591 struct A3
592 : private A1,
593 public virtual A2
594 {
595 char _[93481];
~A3t11::A3596 virtual ~A3() {}
597
getA1t11::A3598 A1* getA1() {return this;}
getA2t11::A3599 A2* getA2() {return this;}
getA3t11::A3600 A3* getA3() {return this;}
601 };
602
test()603 void test()
604 {
605 A1 a1;
606 A2 a2;
607 A3 a3;
608 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
609 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
610 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
611 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
612
613 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
614 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
615 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
616 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
617 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
618
619 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
620 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
621 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
622 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
623 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
624 }
625
626 } // t11
627
628 namespace t12
629 {
630
631 struct A1
632 {
633 char _[43981];
~A1t12::A1634 virtual ~A1() {}
635
getA1t12::A1636 A1* getA1() {return this;}
637 };
638
639 struct A2
640 {
641 char _[34981];
~A2t12::A2642 virtual ~A2() {}
643
getA2t12::A2644 A2* getA2() {return this;}
645 };
646
647 struct A3
648 : private virtual A1,
649 public virtual A2
650 {
651 char _[93481];
~A3t12::A3652 virtual ~A3() {}
653
getA1t12::A3654 A1* getA1() {return this;}
getA2t12::A3655 A2* getA2() {return this;}
getA3t12::A3656 A3* getA3() {return this;}
657 };
658
test()659 void test()
660 {
661 A1 a1;
662 A2 a2;
663 A3 a3;
664 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
665 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
666 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
667 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
668
669 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
670 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
671 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
672 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
673 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
674
675 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
676 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
677 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
678 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
679 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
680 }
681
682 } // t12
683
684 namespace t13
685 {
686
687 struct A1
688 {
689 char _[43981];
~A1t13::A1690 virtual ~A1() {}
691
getA1t13::A1692 A1* getA1() {return this;}
693 };
694
695 struct A2
696 {
697 char _[34981];
~A2t13::A2698 virtual ~A2() {}
699
getA2t13::A2700 A2* getA2() {return this;}
701 };
702
703 struct A3
704 : private A1,
705 private A2
706 {
707 char _[93481];
~A3t13::A3708 virtual ~A3() {}
709
getA1t13::A3710 A1* getA1() {return this;}
getA2t13::A3711 A2* getA2() {return this;}
getA3t13::A3712 A3* getA3() {return this;}
713 };
714
test()715 void test()
716 {
717 A1 a1;
718 A2 a2;
719 A3 a3;
720 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
721 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
722 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
723 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
724
725 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
726 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
727 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
728 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
729
730 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
731 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
732 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
733 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
734 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
735 }
736
737 } // t13
738
739 namespace t14
740 {
741
742 struct A1
743 {
744 char _[43981];
~A1t14::A1745 virtual ~A1() {}
746
getA1t14::A1747 A1* getA1() {return this;}
748 };
749
750 struct A2
751 {
752 char _[34981];
~A2t14::A2753 virtual ~A2() {}
754
getA2t14::A2755 A2* getA2() {return this;}
756 };
757
758 struct A3
759 : private virtual A1,
760 private A2
761 {
762 char _[93481];
~A3t14::A3763 virtual ~A3() {}
764
getA1t14::A3765 A1* getA1() {return this;}
getA2t14::A3766 A2* getA2() {return this;}
getA3t14::A3767 A3* getA3() {return this;}
768 };
769
test()770 void test()
771 {
772 A1 a1;
773 A2 a2;
774 A3 a3;
775 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
776 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
777 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
778 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
779
780 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
781 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
782 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
783 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
784
785 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
786 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
787 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
788 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
789 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
790 }
791
792 } // t14
793
794 namespace t15
795 {
796
797 struct A1
798 {
799 char _[43981];
~A1t15::A1800 virtual ~A1() {}
801
getA1t15::A1802 A1* getA1() {return this;}
803 };
804
805 struct A2
806 {
807 char _[34981];
~A2t15::A2808 virtual ~A2() {}
809
getA2t15::A2810 A2* getA2() {return this;}
811 };
812
813 struct A3
814 : private virtual A1,
815 private virtual A2
816 {
817 char _[93481];
~A3t15::A3818 virtual ~A3() {}
819
getA1t15::A3820 A1* getA1() {return this;}
getA2t15::A3821 A2* getA2() {return this;}
getA3t15::A3822 A3* getA3() {return this;}
823 };
824
test()825 void test()
826 {
827 A1 a1;
828 A2 a2;
829 A3 a3;
830 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
831 assert(dynamic_cast<A1*>(a2.getA2()) == 0);
832 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
833 assert(dynamic_cast<A1*>(a3.getA2()) == 0);
834
835 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
836 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
837 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
838 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
839
840 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
841 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
842 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
843 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
844 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
845 }
846
847 } // t15
848
849 /*
850
851 A1
852 |
853 A2
854 |
855 A3
856
857 */
858
859 namespace t16
860 {
861
862 struct A1
863 {
864 char _[43981];
~A1t16::A1865 virtual ~A1() {}
866
getA1t16::A1867 A1* getA1() {return this;}
868 };
869
870 struct A2
871 : public A1
872 {
873 char _[34981];
~A2t16::A2874 virtual ~A2() {}
875
getA1t16::A2876 A1* getA1() {return this;}
getA2t16::A2877 A2* getA2() {return this;}
878 };
879
880 struct A3
881 : public A2
882 {
883 char _[93481];
~A3t16::A3884 virtual ~A3() {}
885
getA1t16::A3886 A1* getA1() {return this;}
getA2t16::A3887 A2* getA2() {return this;}
getA3t16::A3888 A3* getA3() {return this;}
889 };
890
test()891 void test()
892 {
893 A1 a1;
894 A2 a2;
895 A3 a3;
896 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
897 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
898 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
899 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
900 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
901 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
902
903 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
904 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
905 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
906 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
907 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
908 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
909
910 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
911 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
912 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
913 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
914 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
915 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
916 }
917
918 } // t16
919
920 namespace t17
921 {
922
923 struct A1
924 {
925 char _[43981];
~A1t17::A1926 virtual ~A1() {}
927
getA1t17::A1928 A1* getA1() {return this;}
929 };
930
931 struct A2
932 : public virtual A1
933 {
934 char _[34981];
~A2t17::A2935 virtual ~A2() {}
936
getA1t17::A2937 A1* getA1() {return this;}
getA2t17::A2938 A2* getA2() {return this;}
939 };
940
941 struct A3
942 : public A2
943 {
944 char _[93481];
~A3t17::A3945 virtual ~A3() {}
946
getA1t17::A3947 A1* getA1() {return this;}
getA2t17::A3948 A2* getA2() {return this;}
getA3t17::A3949 A3* getA3() {return this;}
950 };
951
test()952 void test()
953 {
954 A1 a1;
955 A2 a2;
956 A3 a3;
957 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
958 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
959 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
960 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
961 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
962 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
963
964 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
965 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
966 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
967 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
968 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
969 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
970
971 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
972 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
973 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
974 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
975 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
976 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
977 }
978
979 } // t17
980
981 namespace t18
982 {
983
984 struct A1
985 {
986 char _[43981];
~A1t18::A1987 virtual ~A1() {}
988
getA1t18::A1989 A1* getA1() {return this;}
990 };
991
992 struct A2
993 : private A1
994 {
995 char _[34981];
~A2t18::A2996 virtual ~A2() {}
997
getA1t18::A2998 A1* getA1() {return this;}
getA2t18::A2999 A2* getA2() {return this;}
1000 };
1001
1002 struct A3
1003 : public A2
1004 {
1005 char _[93481];
~A3t18::A31006 virtual ~A3() {}
1007
getA2t18::A31008 A2* getA2() {return this;}
getA3t18::A31009 A3* getA3() {return this;}
1010 };
1011
test()1012 void test()
1013 {
1014 A1 a1;
1015 A2 a2;
1016 A3 a3;
1017 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1018 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1019 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1020
1021 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1022 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1023 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1024 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1025 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1026 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1027
1028 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1029 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1030 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1031 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1032 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1033 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1034 }
1035
1036 } // t18
1037
1038 namespace t19
1039 {
1040
1041 struct A1
1042 {
1043 char _[43981];
~A1t19::A11044 virtual ~A1() {}
1045
getA1t19::A11046 A1* getA1() {return this;}
1047 };
1048
1049 struct A2
1050 : protected virtual A1
1051 {
1052 char _[34981];
~A2t19::A21053 virtual ~A2() {}
1054
getA1t19::A21055 A1* getA1() {return this;}
getA2t19::A21056 A2* getA2() {return this;}
1057 };
1058
1059 struct A3
1060 : public A2
1061 {
1062 char _[93481];
~A3t19::A31063 virtual ~A3() {}
1064
getA2t19::A31065 A2* getA2() {return this;}
getA3t19::A31066 A3* getA3() {return this;}
1067 };
1068
test()1069 void test()
1070 {
1071 A1 a1;
1072 A2 a2;
1073 A3 a3;
1074 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1075 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1076 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1077
1078 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1079 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1080 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1081 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1082 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1083 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1084
1085 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1086 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1087 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1088 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1089 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1090 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1091 }
1092
1093 } // t19
1094
1095 namespace t20
1096 {
1097
1098 struct A1
1099 {
1100 char _[43981];
~A1t20::A11101 virtual ~A1() {}
1102
getA1t20::A11103 A1* getA1() {return this;}
1104 };
1105
1106 struct A2
1107 : public virtual A1
1108 {
1109 char _[34981];
~A2t20::A21110 virtual ~A2() {}
1111
getA1t20::A21112 A1* getA1() {return this;}
getA2t20::A21113 A2* getA2() {return this;}
1114 };
1115
1116 struct A3
1117 : public virtual A2
1118 {
1119 char _[93481];
~A3t20::A31120 virtual ~A3() {}
1121
getA1t20::A31122 A1* getA1() {return this;}
getA2t20::A31123 A2* getA2() {return this;}
getA3t20::A31124 A3* getA3() {return this;}
1125 };
1126
test()1127 void test()
1128 {
1129 A1 a1;
1130 A2 a2;
1131 A3 a3;
1132 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1133 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1134 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1135 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1136 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
1137 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
1138
1139 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1140 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1141 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1142 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
1143 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1144 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1145
1146 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1147 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1148 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1149 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
1150 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1151 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1152 }
1153
1154 } // t20
1155
1156 namespace t21
1157 {
1158
1159 struct A1
1160 {
1161 char _[43981];
~A1t21::A11162 virtual ~A1() {}
1163
getA1t21::A11164 A1* getA1() {return this;}
1165 };
1166
1167 struct A2
1168 : private A1
1169 {
1170 char _[34981];
~A2t21::A21171 virtual ~A2() {}
1172
getA1t21::A21173 A1* getA1() {return this;}
getA2t21::A21174 A2* getA2() {return this;}
1175 };
1176
1177 struct A3
1178 : public virtual A2
1179 {
1180 char _[93481];
~A3t21::A31181 virtual ~A3() {}
1182
getA2t21::A31183 A2* getA2() {return this;}
getA3t21::A31184 A3* getA3() {return this;}
1185 };
1186
test()1187 void test()
1188 {
1189 A1 a1;
1190 A2 a2;
1191 A3 a3;
1192 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1193 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1194 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1195
1196 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1197 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1198 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1199 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1200 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1201 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1202
1203 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1204 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1205 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1206 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1207 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1208 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1209 }
1210
1211 } // t21
1212
1213 namespace t22
1214 {
1215
1216 struct A1
1217 {
1218 char _[43981];
~A1t22::A11219 virtual ~A1() {}
1220
getA1t22::A11221 A1* getA1() {return this;}
1222 };
1223
1224 struct A2
1225 : protected virtual A1
1226 {
1227 char _[34981];
~A2t22::A21228 virtual ~A2() {}
1229
getA1t22::A21230 A1* getA1() {return this;}
getA2t22::A21231 A2* getA2() {return this;}
1232 };
1233
1234 struct A3
1235 : public virtual A2
1236 {
1237 char _[93481];
~A3t22::A31238 virtual ~A3() {}
1239
getA2t22::A31240 A2* getA2() {return this;}
getA3t22::A31241 A3* getA3() {return this;}
1242 };
1243
test()1244 void test()
1245 {
1246 A1 a1;
1247 A2 a2;
1248 A3 a3;
1249 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1250 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1251 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1252
1253 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1254 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1255 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1256 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1257 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1258 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1259
1260 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1261 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1262 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1263 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1264 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1265 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1266 }
1267
1268 } // t22
1269
1270 namespace t23
1271 {
1272
1273 struct A1
1274 {
1275 char _[43981];
~A1t23::A11276 virtual ~A1() {}
1277
getA1t23::A11278 A1* getA1() {return this;}
1279 };
1280
1281 struct A2
1282 : private A1
1283 {
1284 char _[34981];
~A2t23::A21285 virtual ~A2() {}
1286
getA1t23::A21287 A1* getA1() {return this;}
getA2t23::A21288 A2* getA2() {return this;}
1289 };
1290
1291 struct A3
1292 : private A2
1293 {
1294 char _[93481];
~A3t23::A31295 virtual ~A3() {}
1296
getA1t23::A31297 t23::A1* getA1() {return A2::getA1();}
getA2t23::A31298 A2* getA2() {return this;}
getA3t23::A31299 A3* getA3() {return this;}
1300 };
1301
test()1302 void test()
1303 {
1304 A1 a1;
1305 A2 a2;
1306 A3 a3;
1307 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1308 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1309 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1310
1311 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1312 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1313 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1314 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1315 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1316
1317 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1318 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1319 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1320 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1321 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1322 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1323 }
1324
1325 } // t23
1326
1327 namespace t24
1328 {
1329
1330 struct A1
1331 {
1332 char _[43981];
~A1t24::A11333 virtual ~A1() {}
1334
getA1t24::A11335 A1* getA1() {return this;}
1336 };
1337
1338 struct A2
1339 : protected virtual A1
1340 {
1341 char _[34981];
~A2t24::A21342 virtual ~A2() {}
1343
getA1t24::A21344 A1* getA1() {return this;}
getA2t24::A21345 A2* getA2() {return this;}
1346 };
1347
1348 struct A3
1349 : private A2
1350 {
1351 char _[93481];
~A3t24::A31352 virtual ~A3() {}
1353
getA1t24::A31354 t24::A1* getA1() {return A2::getA1();}
getA2t24::A31355 A2* getA2() {return this;}
getA3t24::A31356 A3* getA3() {return this;}
1357 };
1358
test()1359 void test()
1360 {
1361 A1 a1;
1362 A2 a2;
1363 A3 a3;
1364 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1365 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1366 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1367
1368 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1369 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1370 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1371 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1372 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1373
1374 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1375 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1376 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1377 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1378 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1379 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1380 }
1381
1382 } // t24
1383
1384 namespace t25
1385 {
1386
1387 struct A1
1388 {
1389 char _[43981];
~A1t25::A11390 virtual ~A1() {}
1391
getA1t25::A11392 A1* getA1() {return this;}
1393 };
1394
1395 struct A2
1396 : protected virtual A1
1397 {
1398 char _[34981];
~A2t25::A21399 virtual ~A2() {}
1400
getA1t25::A21401 A1* getA1() {return this;}
getA2t25::A21402 A2* getA2() {return this;}
1403 };
1404
1405 struct A3
1406 : private virtual A2
1407 {
1408 char _[93481];
~A3t25::A31409 virtual ~A3() {}
1410
getA1t25::A31411 t25::A1* getA1() {return A2::getA1();}
getA2t25::A31412 A2* getA2() {return this;}
getA3t25::A31413 A3* getA3() {return this;}
1414 };
1415
test()1416 void test()
1417 {
1418 A1 a1;
1419 A2 a2;
1420 A3 a3;
1421 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1422 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1423 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1424
1425 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1426 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1427 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1428 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
1429 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1430
1431 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1432 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1433 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1434 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
1435 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1436 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1437 }
1438
1439 } // t25
1440
1441 /*
1442
1443 A1 A1
1444 | |
1445 A2 |
1446 \ |
1447 A3
1448
1449 */
1450
1451 namespace t26
1452 {
1453
1454 struct A1
1455 {
1456 char _[43981];
~A1t26::A11457 virtual ~A1() {}
1458
getA1t26::A11459 A1* getA1() {return this;}
1460 };
1461
1462 struct A2
1463 : public A1
1464 {
1465 char _[34981];
~A2t26::A21466 virtual ~A2() {}
1467
getA1t26::A21468 A1* getA1() {return this;}
getA2t26::A21469 A2* getA2() {return this;}
1470 };
1471
1472 struct A3
1473 : public A1,
1474 public A2
1475 {
1476 char _[93481];
~A3t26::A31477 virtual ~A3() {}
1478
getA12t26::A31479 A1* getA12() {return A2::getA1();}
getA2t26::A31480 A2* getA2() {return this;}
getA3t26::A31481 A3* getA3() {return this;}
1482 };
1483
test()1484 void test()
1485 {
1486 A1 a1;
1487 A2 a2;
1488 A3 a3;
1489 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1490 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1491 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1492 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1493 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1494
1495 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1496 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1497 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1498 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1499 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1500 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1501
1502 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1503 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1504 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1505 assert(dynamic_cast<A3*>(a3.getA12()) == a3.getA3());
1506 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1507 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1508 }
1509
1510 } // t26
1511
1512 namespace t27
1513 {
1514
1515 struct A1
1516 {
1517 char _[43981];
~A1t27::A11518 virtual ~A1() {}
1519
getA1t27::A11520 A1* getA1() {return this;}
1521 };
1522
1523 struct A2
1524 : private A1
1525 {
1526 char _[34981];
~A2t27::A21527 virtual ~A2() {}
1528
getA1t27::A21529 A1* getA1() {return this;}
getA2t27::A21530 A2* getA2() {return this;}
1531 };
1532
1533 struct A3
1534 : public A1,
1535 public A2
1536 {
1537 char _[93481];
~A3t27::A31538 virtual ~A3() {}
1539
getA12t27::A31540 A1* getA12() {return A2::getA1();}
getA2t27::A31541 A2* getA2() {return this;}
getA3t27::A31542 A3* getA3() {return this;}
1543 };
1544
test()1545 void test()
1546 {
1547 A1 a1;
1548 A2 a2;
1549 A3 a3;
1550 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1551 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1552 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1553
1554 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1555 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1556 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1557 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1558 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1559 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1560
1561 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1562 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1563 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1564 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1565 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1566 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1567 }
1568
1569 } // t27
1570
1571 namespace t28
1572 {
1573
1574 struct A1
1575 {
1576 char _[43981];
~A1t28::A11577 virtual ~A1() {}
1578
getA1t28::A11579 A1* getA1() {return this;}
1580 };
1581
1582 struct A2
1583 : public A1
1584 {
1585 char _[34981];
~A2t28::A21586 virtual ~A2() {}
1587
getA1t28::A21588 A1* getA1() {return this;}
getA2t28::A21589 A2* getA2() {return this;}
1590 };
1591
1592 struct A3
1593 : private A1,
1594 public A2
1595 {
1596 char _[93481];
~A3t28::A31597 virtual ~A3() {}
1598
getA12t28::A31599 A1* getA12() {return A2::getA1();}
getA2t28::A31600 A2* getA2() {return this;}
getA3t28::A31601 A3* getA3() {return this;}
1602 };
1603
test()1604 void test()
1605 {
1606 A1 a1;
1607 A2 a2;
1608 A3 a3;
1609 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1610 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1611 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1612 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1613
1614 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1615 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1616 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1617 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1618 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1619 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1620
1621 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1622 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1623 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1624 assert(dynamic_cast<A3*>(a3.getA12()) == a3.getA3());
1625 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1626 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1627 }
1628
1629 } // t28
1630
1631 namespace t29
1632 {
1633
1634 struct A1
1635 {
1636 char _[43981];
~A1t29::A11637 virtual ~A1() {}
1638
getA1t29::A11639 A1* getA1() {return this;}
1640 };
1641
1642 struct A2
1643 : public A1
1644 {
1645 char _[34981];
~A2t29::A21646 virtual ~A2() {}
1647
getA1t29::A21648 A1* getA1() {return this;}
getA2t29::A21649 A2* getA2() {return this;}
1650 };
1651
1652 struct A3
1653 : public A1,
1654 private A2
1655 {
1656 char _[93481];
~A3t29::A31657 virtual ~A3() {}
1658
getA12t29::A31659 A1* getA12() {return A2::getA1();}
getA2t29::A31660 A2* getA2() {return this;}
getA3t29::A31661 A3* getA3() {return this;}
1662 };
1663
test()1664 void test()
1665 {
1666 A1 a1;
1667 A2 a2;
1668 A3 a3;
1669 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1670 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1671 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1672 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1673
1674 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1675 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1676 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1677 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1678 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1679
1680 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1681 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1682 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1683 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1684 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1685 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1686 }
1687
1688 } // t29
1689
1690 namespace t30
1691 {
1692
1693 struct A1
1694 {
1695 char _[43981];
~A1t30::A11696 virtual ~A1() {}
1697
getA1t30::A11698 A1* getA1() {return this;}
1699 };
1700
1701 struct A2
1702 : public A1
1703 {
1704 char _[34981];
~A2t30::A21705 virtual ~A2() {}
1706
getA1t30::A21707 A1* getA1() {return this;}
getA2t30::A21708 A2* getA2() {return this;}
1709 };
1710
1711 struct A3
1712 : private A1,
1713 private A2
1714 {
1715 char _[93481];
~A3t30::A31716 virtual ~A3() {}
1717
getA12t30::A31718 A1* getA12() {return A2::getA1();}
getA2t30::A31719 A2* getA2() {return this;}
getA3t30::A31720 A3* getA3() {return this;}
1721 };
1722
test()1723 void test()
1724 {
1725 A1 a1;
1726 A2 a2;
1727 A3 a3;
1728 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1729 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1730 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1731 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1732 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA12());
1733
1734 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1735 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1736 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1737 assert(dynamic_cast<A2*>(a3.getA12()) == a3.getA2());
1738 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1739
1740 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1741 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1742 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1743 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1744 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1745 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1746 }
1747
1748 } // t30
1749
1750 namespace t31
1751 {
1752
1753 struct A1
1754 {
1755 char _[43981];
~A1t31::A11756 virtual ~A1() {}
1757
getA1t31::A11758 A1* getA1() {return this;}
1759 };
1760
1761 struct A2
1762 : private A1
1763 {
1764 char _[34981];
~A2t31::A21765 virtual ~A2() {}
1766
getA1t31::A21767 A1* getA1() {return this;}
getA2t31::A21768 A2* getA2() {return this;}
1769 };
1770
1771 struct A3
1772 : public A1,
1773 private A2
1774 {
1775 char _[93481];
~A3t31::A31776 virtual ~A3() {}
1777
getA12t31::A31778 A1* getA12() {return A2::getA1();}
getA2t31::A31779 A2* getA2() {return this;}
getA3t31::A31780 A3* getA3() {return this;}
1781 };
1782
test()1783 void test()
1784 {
1785 A1 a1;
1786 A2 a2;
1787 A3 a3;
1788 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1789 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1790 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1791
1792 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1793 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1794 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1795 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1796 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1797
1798 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1799 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1800 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1801 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1802 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1803 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1804 }
1805
1806 } // t31
1807
1808 namespace t32
1809 {
1810
1811 struct A1
1812 {
1813 char _[43981];
~A1t32::A11814 virtual ~A1() {}
1815
getA1t32::A11816 A1* getA1() {return this;}
1817 };
1818
1819 struct A2
1820 : private A1
1821 {
1822 char _[34981];
~A2t32::A21823 virtual ~A2() {}
1824
getA1t32::A21825 A1* getA1() {return this;}
getA2t32::A21826 A2* getA2() {return this;}
1827 };
1828
1829 struct A3
1830 : private A1,
1831 public A2
1832 {
1833 char _[93481];
~A3t32::A31834 virtual ~A3() {}
1835
getA12t32::A31836 A1* getA12() {return A2::getA1();}
getA2t32::A31837 A2* getA2() {return this;}
getA3t32::A31838 A3* getA3() {return this;}
1839 };
1840
test()1841 void test()
1842 {
1843 A1 a1;
1844 A2 a2;
1845 A3 a3;
1846 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1847 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1848 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1849
1850 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1851 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1852 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1853 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1854 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1855
1856 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1857 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1858 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1859 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1860 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1861 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1862 }
1863
1864 } // t32
1865
1866 namespace t33
1867 {
1868
1869 struct A1
1870 {
1871 char _[43981];
~A1t33::A11872 virtual ~A1() {}
1873
getA1t33::A11874 A1* getA1() {return this;}
1875 };
1876
1877 struct A2
1878 : private A1
1879 {
1880 char _[34981];
~A2t33::A21881 virtual ~A2() {}
1882
getA1t33::A21883 A1* getA1() {return this;}
getA2t33::A21884 A2* getA2() {return this;}
1885 };
1886
1887 struct A3
1888 : private A1,
1889 private A2
1890 {
1891 char _[93481];
~A3t33::A31892 virtual ~A3() {}
1893
getA12t33::A31894 A1* getA12() {return A2::getA1();}
getA2t33::A31895 A2* getA2() {return this;}
getA3t33::A31896 A3* getA3() {return this;}
1897 };
1898
test()1899 void test()
1900 {
1901 A1 a1;
1902 A2 a2;
1903 A3 a3;
1904 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1905 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1906 assert(dynamic_cast<A1*>(a3.getA12()) == a3.getA12());
1907
1908 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1909 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
1910 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1911 assert(dynamic_cast<A2*>(a3.getA12()) == 0);
1912 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1913
1914 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1915 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1916 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1917 assert(dynamic_cast<A3*>(a3.getA12()) == 0);
1918 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
1919 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1920 }
1921
1922 } // t33
1923
1924 /*
1925
1926 A1
1927 | \
1928 A2 \
1929 \ |
1930 A3
1931
1932 */
1933
1934 namespace t34
1935 {
1936
1937 struct A1
1938 {
1939 char _[43981];
~A1t34::A11940 virtual ~A1() {}
1941
getA1t34::A11942 A1* getA1() {return this;}
1943 };
1944
1945 struct A2
1946 : public virtual A1
1947 {
1948 char _[34981];
~A2t34::A21949 virtual ~A2() {}
1950
getA1t34::A21951 A1* getA1() {return this;}
getA2t34::A21952 A2* getA2() {return this;}
1953 };
1954
1955 struct A3
1956 : public virtual A1,
1957 public A2
1958 {
1959 char _[93481];
~A3t34::A31960 virtual ~A3() {}
1961
getA1t34::A31962 A1* getA1() {return A1::getA1();}
getA2t34::A31963 A2* getA2() {return this;}
getA3t34::A31964 A3* getA3() {return this;}
1965 };
1966
test()1967 void test()
1968 {
1969 A1 a1;
1970 A2 a2;
1971 A3 a3;
1972 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
1973 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
1974 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
1975 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
1976 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
1977 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
1978
1979 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
1980 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
1981 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
1982 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
1983 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
1984 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
1985
1986 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
1987 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
1988 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
1989 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
1990 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
1991 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
1992 }
1993
1994 } // t34
1995
1996 namespace t35
1997 {
1998
1999 struct A1
2000 {
2001 char _[43981];
~A1t35::A12002 virtual ~A1() {}
2003
getA1t35::A12004 A1* getA1() {return this;}
2005 };
2006
2007 struct A2
2008 : private virtual A1
2009 {
2010 char _[34981];
~A2t35::A22011 virtual ~A2() {}
2012
getA1t35::A22013 A1* getA1() {return this;}
getA2t35::A22014 A2* getA2() {return this;}
2015 };
2016
2017 struct A3
2018 : public virtual A1,
2019 public A2
2020 {
2021 char _[93481];
~A3t35::A32022 virtual ~A3() {}
2023
getA1t35::A32024 A1* getA1() {return A1::getA1();}
getA2t35::A32025 A2* getA2() {return this;}
getA3t35::A32026 A3* getA3() {return this;}
2027 };
2028
test()2029 void test()
2030 {
2031 A1 a1;
2032 A2 a2;
2033 A3 a3;
2034 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2035 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2036 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2037 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2038
2039 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2040 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2041 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2042 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2043 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2044 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2045
2046 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2047 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2048 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2049 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2050 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2051 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2052 }
2053
2054 } // t35
2055
2056 namespace t36
2057 {
2058
2059 struct A1
2060 {
2061 char _[43981];
~A1t36::A12062 virtual ~A1() {}
2063
getA1t36::A12064 A1* getA1() {return this;}
2065 };
2066
2067 struct A2
2068 : public virtual A1
2069 {
2070 char _[34981];
~A2t36::A22071 virtual ~A2() {}
2072
getA1t36::A22073 A1* getA1() {return this;}
getA2t36::A22074 A2* getA2() {return this;}
2075 };
2076
2077 struct A3
2078 : private virtual A1,
2079 public A2
2080 {
2081 char _[93481];
~A3t36::A32082 virtual ~A3() {}
2083
getA1t36::A32084 A1* getA1() {return A1::getA1();}
getA2t36::A32085 A2* getA2() {return this;}
getA3t36::A32086 A3* getA3() {return this;}
2087 };
2088
test()2089 void test()
2090 {
2091 A1 a1;
2092 A2 a2;
2093 A3 a3;
2094 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2095 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2096 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2097 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2098 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2099 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2100
2101 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2102 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2103 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2104 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2105 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2106 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2107
2108 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2109 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2110 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2111 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2112 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2113 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2114 }
2115
2116 } // t36
2117
2118 namespace t37
2119 {
2120
2121 struct A1
2122 {
2123 char _[43981];
~A1t37::A12124 virtual ~A1() {}
2125
getA1t37::A12126 A1* getA1() {return this;}
2127 };
2128
2129 struct A2
2130 : public virtual A1
2131 {
2132 char _[34981];
~A2t37::A22133 virtual ~A2() {}
2134
getA1t37::A22135 A1* getA1() {return this;}
getA2t37::A22136 A2* getA2() {return this;}
2137 };
2138
2139 struct A3
2140 : public virtual A1,
2141 private A2
2142 {
2143 char _[93481];
~A3t37::A32144 virtual ~A3() {}
2145
getA1t37::A32146 A1* getA1() {return A1::getA1();}
getA2t37::A32147 A2* getA2() {return this;}
getA3t37::A32148 A3* getA3() {return this;}
2149 };
2150
test()2151 void test()
2152 {
2153 A1 a1;
2154 A2 a2;
2155 A3 a3;
2156 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2157 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2158 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2159 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2160 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2161 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2162
2163 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2164 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2165 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2166 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2167 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2168
2169 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2170 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2171 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2172 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2173 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2174 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2175 }
2176
2177 } // t37
2178
2179 namespace t38
2180 {
2181
2182 struct A1
2183 {
2184 char _[43981];
~A1t38::A12185 virtual ~A1() {}
2186
getA1t38::A12187 A1* getA1() {return this;}
2188 };
2189
2190 struct A2
2191 : public virtual A1
2192 {
2193 char _[34981];
~A2t38::A22194 virtual ~A2() {}
2195
getA1t38::A22196 A1* getA1() {return this;}
getA2t38::A22197 A2* getA2() {return this;}
2198 };
2199
2200 struct A3
2201 : private virtual A1,
2202 private A2
2203 {
2204 char _[93481];
~A3t38::A32205 virtual ~A3() {}
2206
getA1t38::A32207 A1* getA1() {return A1::getA1();}
getA2t38::A32208 A2* getA2() {return this;}
getA3t38::A32209 A3* getA3() {return this;}
2210 };
2211
test()2212 void test()
2213 {
2214 A1 a1;
2215 A2 a2;
2216 A3 a3;
2217 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2218 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2219 assert(dynamic_cast<A1*>(a2.getA2()) == a2.getA1());
2220 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2221 assert(dynamic_cast<A1*>(a3.getA2()) == a3.getA1());
2222
2223 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2224 assert(dynamic_cast<A2*>(a2.getA1()) == a2.getA2());
2225 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2226 assert(dynamic_cast<A2*>(a3.getA1()) == a3.getA2());
2227 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2228
2229 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2230 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2231 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2232 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2233 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2234 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2235 }
2236
2237 } // t38
2238
2239 namespace t39
2240 {
2241
2242 struct A1
2243 {
2244 char _[43981];
~A1t39::A12245 virtual ~A1() {}
2246
getA1t39::A12247 A1* getA1() {return this;}
2248 };
2249
2250 struct A2
2251 : private virtual A1
2252 {
2253 char _[34981];
~A2t39::A22254 virtual ~A2() {}
2255
getA1t39::A22256 A1* getA1() {return this;}
getA2t39::A22257 A2* getA2() {return this;}
2258 };
2259
2260 struct A3
2261 : public virtual A1,
2262 private A2
2263 {
2264 char _[93481];
~A3t39::A32265 virtual ~A3() {}
2266
getA1t39::A32267 A1* getA1() {return A1::getA1();}
getA2t39::A32268 A2* getA2() {return this;}
getA3t39::A32269 A3* getA3() {return this;}
2270 };
2271
test()2272 void test()
2273 {
2274 A1 a1;
2275 A2 a2;
2276 A3 a3;
2277 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2278 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2279 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2280 assert(dynamic_cast<A1*>(a3.getA3()) == a3.getA1());
2281
2282 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2283 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2284 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2285 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2286 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2287
2288 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2289 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2290 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2291 assert(dynamic_cast<A3*>(a3.getA1()) == a3.getA3());
2292 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2293 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2294 }
2295
2296 } // t39
2297
2298 namespace t40
2299 {
2300
2301 struct A1
2302 {
2303 char _[43981];
~A1t40::A12304 virtual ~A1() {}
2305
getA1t40::A12306 A1* getA1() {return this;}
2307 };
2308
2309 struct A2
2310 : private virtual A1
2311 {
2312 char _[34981];
~A2t40::A22313 virtual ~A2() {}
2314
getA1t40::A22315 A1* getA1() {return this;}
getA2t40::A22316 A2* getA2() {return this;}
2317 };
2318
2319 struct A3
2320 : private virtual A1,
2321 public A2
2322 {
2323 char _[93481];
~A3t40::A32324 virtual ~A3() {}
2325
getA1t40::A32326 A1* getA1() {return A1::getA1();}
getA2t40::A32327 A2* getA2() {return this;}
getA3t40::A32328 A3* getA3() {return this;}
2329 };
2330
test()2331 void test()
2332 {
2333 A1 a1;
2334 A2 a2;
2335 A3 a3;
2336 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2337 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2338 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2339
2340 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2341 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2342 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2343 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2344 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2345 assert(dynamic_cast<A2*>(a3.getA3()) == a3.getA2());
2346
2347 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2348 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2349 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2350 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2351 assert(dynamic_cast<A3*>(a3.getA2()) == a3.getA3());
2352 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2353 }
2354
2355 } // t40
2356
2357 namespace t41
2358 {
2359
2360 struct A1
2361 {
2362 char _[43981];
~A1t41::A12363 virtual ~A1() {}
2364
getA1t41::A12365 A1* getA1() {return this;}
2366 };
2367
2368 struct A2
2369 : private virtual A1
2370 {
2371 char _[34981];
~A2t41::A22372 virtual ~A2() {}
2373
getA1t41::A22374 A1* getA1() {return this;}
getA2t41::A22375 A2* getA2() {return this;}
2376 };
2377
2378 struct A3
2379 : private virtual A1,
2380 private A2
2381 {
2382 char _[93481];
~A3t41::A32383 virtual ~A3() {}
2384
getA1t41::A32385 A1* getA1() {return A1::getA1();}
getA2t41::A32386 A2* getA2() {return this;}
getA3t41::A32387 A3* getA3() {return this;}
2388 };
2389
test()2390 void test()
2391 {
2392 A1 a1;
2393 A2 a2;
2394 A3 a3;
2395 assert(dynamic_cast<A1*>(a1.getA1()) == a1.getA1());
2396 assert(dynamic_cast<A1*>(a2.getA1()) == a2.getA1());
2397 assert(dynamic_cast<A1*>(a3.getA1()) == a3.getA1());
2398
2399 assert(dynamic_cast<A2*>(a1.getA1()) == 0);
2400 assert(dynamic_cast<A2*>(a2.getA1()) == 0);
2401 assert(dynamic_cast<A2*>(a2.getA2()) == a2.getA2());
2402 assert(dynamic_cast<A2*>(a3.getA1()) == 0);
2403 assert(dynamic_cast<A2*>(a3.getA2()) == a3.getA2());
2404
2405 assert(dynamic_cast<A3*>(a1.getA1()) == 0);
2406 assert(dynamic_cast<A3*>(a2.getA1()) == 0);
2407 assert(dynamic_cast<A3*>(a2.getA2()) == 0);
2408 assert(dynamic_cast<A3*>(a3.getA1()) == 0);
2409 assert(dynamic_cast<A3*>(a3.getA2()) == 0);
2410 assert(dynamic_cast<A3*>(a3.getA3()) == a3.getA3());
2411 }
2412
2413 } // t41
2414
main()2415 int main()
2416 {
2417 timer t;
2418 t1::test();
2419 t2::test();
2420 t3::test();
2421 t4::test();
2422 t5::test();
2423 t6::test();
2424 t7::test();
2425 t8::test();
2426 t9::test();
2427 t10::test();
2428 t11::test();
2429 t12::test();
2430 t13::test();
2431 t14::test();
2432 t15::test();
2433 t16::test();
2434 t17::test();
2435 t18::test();
2436 t19::test();
2437 t20::test();
2438 t21::test();
2439 t22::test();
2440 t23::test();
2441 t24::test();
2442 t25::test();
2443 t26::test();
2444 t27::test();
2445 t28::test();
2446 t29::test();
2447 t30::test();
2448 t31::test();
2449 t32::test();
2450 t33::test();
2451 t34::test();
2452 t35::test();
2453 t36::test();
2454 t37::test();
2455 t38::test();
2456 t39::test();
2457 t40::test();
2458 t41::test();
2459 }
2460