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