libcxxabi/test/dynamic_cast3.pass.cpp

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