libcxxabi/test/catch_class_04.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 /*
  10     This test checks that adjustedPtr is correct as there exist offsets in this
  11     object for the various subobjects, all of which have a unique id_ to
  12     check against.  It also checks that virtual bases work properly
  13 */
  14
  15 // UNSUPPORTED: no-exceptions
  16
  17 // Compilers emit warnings about exceptions of type 'Child' being caught by
  18 // an earlier handler of type 'Base'. Congrats, you've just diagnosed the
  19 // behavior under test.
  20 // ADDITIONAL_COMPILE_FLAGS: -Wno-exceptions
  21
  22 #include <exception>
  23 #include <stdlib.h>
  24 #include <assert.h>
  25
  26 struct B
  27 {
  28     static int count;
  29     int id_;
  30     explicit B(int id) : id_(id) {count++;}
  31     B(const B& a) : id_(a.id_) {count++;}
  32     ~B() {count--;}
  33 };
  34
  35 int B::count = 0;
  36
  37 struct C1
  38     : virtual B
  39 {
  40     static int count;
  41     int id_;
  42     explicit C1(int id) : B(id-2), id_(id) {count++;}
  43     C1(const C1& a) : B(a.id_-2), id_(a.id_) {count++;}
  44     ~C1() {count--;}
  45 };
  46
  47 int C1::count = 0;
  48
  49 struct C2
  50     : virtual private B
  51 {
  52     static int count;
  53     int id_;
  54     explicit C2(int id) : B(id-2), id_(id) {count++;}
  55     C2(const C2& a) : B(a.id_-2), id_(a.id_) {count++;}
  56     ~C2() {count--;}
  57 };
  58
  59 int C2::count = 0;
  60
  61 struct A
  62     : C1, C2
  63 {
  64     static int count;
  65     int id_;
  66     explicit A(int id) : B(id+3), C1(id-1), C2(id-2), id_(id) {count++;}
  67     A(const A& a) :  B(a.id_+3), C1(a.id_-1), C2(a.id_-2), id_(a.id_) {count++;}
  68     ~A() {count--;}
  69 };
  70
  71 int A::count = 0;
  72
  73 void f1()
  74 {
  75     assert(A::count == 0);
  76     assert(C1::count == 0);
  77     assert(C2::count == 0);
  78     assert(B::count == 0);
  79     A a(5);
  80     assert(A::count == 1);
  81     assert(C1::count == 1);
  82     assert(C2::count == 1);
  83     assert(B::count == 1);
  84
  85     assert(a.id_ == 5);
  86     assert(static_cast<C1&>(a).id_ == 4);
  87     assert(static_cast<C2&>(a).id_ == 3);
  88     assert(static_cast<B&>(a).id_ == 8);
  89     throw a;
  90     assert(false);
  91 }
  92
  93 void f2()
  94 {
  95     try
  96     {
  97         assert(A::count == 0);
  98         assert(C1::count == 0);
  99         assert(C2::count == 0);
 100         assert(B::count == 0);
 101         f1();
 102         assert(false);
 103     }
 104     catch (const A& a)  // can catch A
 105     {
 106         assert(a.id_ == 5);
 107         assert(static_cast<const C1&>(a).id_ == 4);
 108         assert(static_cast<const C2&>(a).id_ == 3);
 109         assert(static_cast<const B&>(a).id_ == 8);
 110         throw;
 111     }
 112     catch (const C1&)
 113     {
 114         assert(false);
 115     }
 116     catch (const C2&)
 117     {
 118         assert(false);
 119     }
 120     catch (const B&)
 121     {
 122         assert(false);
 123     }
 124 }
 125
 126 void f3()
 127 {
 128     try
 129     {
 130         assert(A::count == 0);
 131         assert(C1::count == 0);
 132         assert(C2::count == 0);
 133         assert(B::count == 0);
 134         f2();
 135         assert(false);
 136     }
 137     catch (const B& a)  // can catch B
 138     {
 139         assert(static_cast<const B&>(a).id_ == 8);
 140         throw;
 141     }
 142     catch (const C1& c1)
 143     {
 144         assert(false);
 145     }
 146     catch (const C2&)
 147     {
 148         assert(false);
 149     }
 150 }
 151
 152 void f4()
 153 {
 154     try
 155     {
 156         assert(A::count == 0);
 157         assert(C1::count == 0);
 158         assert(C2::count == 0);
 159         assert(B::count == 0);
 160         f3();
 161         assert(false);
 162     }
 163     catch (const C2& c2)  // can catch C2
 164     {
 165         assert(c2.id_ == 3);
 166         throw;
 167     }
 168     catch (const B& a)  // can not catch B (ambiguous base)
 169     {
 170         assert(false);
 171     }
 172     catch (const C1&)
 173     {
 174         assert(false);
 175     }
 176 }
 177
 178 void f5()
 179 {
 180     try
 181     {
 182         assert(A::count == 0);
 183         assert(C1::count == 0);
 184         assert(C2::count == 0);
 185         assert(B::count == 0);
 186         f4();
 187         assert(false);
 188     }
 189     catch (const C1& c1)  // can catch C1
 190     {
 191         assert(c1.id_ == 4);
 192         assert(static_cast<const B&>(c1).id_ == 8);
 193         throw;
 194     }
 195     catch (const B& a)
 196     {
 197         assert(false);
 198     }
 199     catch (const C2&)
 200     {
 201         assert(false);
 202     }
 203 }
 204
 205 int main(int, char**)
 206 {
 207     try
 208     {
 209         f5();
 210         assert(false);
 211     }
 212     catch (...)
 213     {
 214     }
 215     assert(A::count == 0);
 216     assert(C1::count == 0);
 217     assert(C2::count == 0);
 218     assert(B::count == 0);
 219
 220     return 0;
 221 }