libcxxabi/test/catch_class_03.pass.cpp

   1 //===---------------------- catch_class_03.cpp ----------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 /*
  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.
  13 */
  14
  15 // UNSUPPORTED: no-exceptions
  16
  17 #include <exception>
  18 #include <stdlib.h>
  19 #include <assert.h>
  20
  21 // Clang emits  warnings about exceptions of type 'Child' being caught by
  22 // an earlier handler of type 'Base'. Congrats clang, you've just
  23 // diagnosed the behavior under test.
  24 #if defined(__clang__)
  25 #pragma clang diagnostic ignored "-Wexceptions"
  26 #endif
  27
  28 struct B
  29 {
  30     static int count;
  31     int id_;
  32     explicit B(int id) : id_(id) {count++;}
  33     B(const B& a) : id_(a.id_) {count++;}
  34     ~B() {count--;}
  35 };
  36
  37 int B::count = 0;
  38
  39 struct C1
  40     : B
  41 {
  42     static int count;
  43     int id_;
  44     explicit C1(int id) : B(id-2), id_(id) {count++;}
  45     C1(const C1& a) : B(a.id_-2), id_(a.id_) {count++;}
  46     ~C1() {count--;}
  47 };
  48
  49 int C1::count = 0;
  50
  51 struct C2
  52     : B
  53 {
  54     static int count;
  55     int id_;
  56     explicit C2(int id) : B(id-2), id_(id) {count++;}
  57     C2(const C2& a) : B(a.id_-2), id_(a.id_) {count++;}
  58     ~C2() {count--;}
  59 };
  60
  61 int C2::count = 0;
  62
  63 struct A
  64     : C1, C2
  65 {
  66     static int count;
  67     int id_;
  68     explicit A(int id) : C1(id-1), C2(id-2), id_(id) {count++;}
  69     A(const A& a) : C1(a.id_-1), C2(a.id_-2), id_(a.id_) {count++;}
  70     ~A() {count--;}
  71 };
  72
  73 int A::count = 0;
  74
  75 void f1()
  76 {
  77     assert(A::count == 0);
  78     assert(C1::count == 0);
  79     assert(C2::count == 0);
  80     assert(B::count == 0);
  81     A a(5);
  82     assert(A::count == 1);
  83     assert(C1::count == 1);
  84     assert(C2::count == 1);
  85     assert(B::count == 2);
  86
  87     assert(a.id_ == 5);
  88     assert(static_cast<C1&>(a).id_ == 4);
  89     assert(static_cast<C2&>(a).id_ == 3);
  90     assert(static_cast<B&>(static_cast<C1&>(a)).id_ == 2);
  91     assert(static_cast<B&>(static_cast<C2&>(a)).id_ == 1);
  92     throw a;
  93     assert(false);
  94 }
  95
  96 void f2()
  97 {
  98     try
  99     {
 100         assert(A::count == 0);
 101         assert(C1::count == 0);
 102         assert(C2::count == 0);
 103         assert(B::count == 0);
 104         f1();
 105         assert(false);
 106     }
 107     catch (const A& a)  // can catch A
 108     {
 109         assert(a.id_ == 5);
 110         assert(static_cast<const C1&>(a).id_ == 4);
 111         assert(static_cast<const C2&>(a).id_ == 3);
 112         assert(static_cast<const B&>(static_cast<const C1&>(a)).id_ == 2);
 113         assert(static_cast<const B&>(static_cast<const C2&>(a)).id_ == 1);
 114         throw;
 115     }
 116     catch (const C1&)
 117     {
 118         assert(false);
 119     }
 120     catch (const C2&)
 121     {
 122         assert(false);
 123     }
 124     catch (const B&)
 125     {
 126         assert(false);
 127     }
 128 }
 129
 130 void f3()
 131 {
 132     try
 133     {
 134         assert(A::count == 0);
 135         assert(C1::count == 0);
 136         assert(C2::count == 0);
 137         assert(B::count == 0);
 138         f2();
 139         assert(false);
 140     }
 141     catch (const B& a)  // can not catch B (ambiguous base)
 142     {
 143         assert(false);
 144     }
 145     catch (const C1& c1)  // can catch C1
 146     {
 147         assert(c1.id_ == 4);
 148         assert(static_cast<const B&>(c1).id_ == 2);
 149         throw;
 150     }
 151     catch (const C2&)
 152     {
 153         assert(false);
 154     }
 155 }
 156
 157 void f4()
 158 {
 159     try
 160     {
 161         assert(A::count == 0);
 162         assert(C1::count == 0);
 163         assert(C2::count == 0);
 164         assert(B::count == 0);
 165         f3();
 166         assert(false);
 167     }
 168     catch (const B& a)  // can not catch B (ambiguous base)
 169     {
 170         assert(false);
 171     }
 172     catch (const C2& c2)  // can catch C2
 173     {
 174         assert(c2.id_ == 3);
 175         assert(static_cast<const B&>(c2).id_ == 1);
 176         throw;
 177     }
 178     catch (const C1&)
 179     {
 180         assert(false);
 181     }
 182 }
 183
 184 int main()
 185 {
 186     try
 187     {
 188         f4();
 189         assert(false);
 190     }
 191     catch (...)
 192     {
 193     }
 194     assert(A::count == 0);
 195     assert(C1::count == 0);
 196     assert(C2::count == 0);
 197     assert(B::count == 0);
 198 }