libcxxabi/test/catch_ptr.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 A global_a(5);
  74
  75 void f1()
  76 {
  77     throw &global_a;
  78     assert(false);
  79 }
  80
  81 void f2()
  82 {
  83     try
  84     {
  85         f1();
  86         assert(false);
  87     }
  88     catch (const A* a)  // can catch A
  89     {
  90         assert(a->id_ == 5);
  91         assert(static_cast<const C1*>(a)->id_ == 4);
  92         assert(static_cast<const C2*>(a)->id_ == 3);
  93         assert(static_cast<const B*>(a)->id_ == 8);
  94         throw;
  95     }
  96     catch (const C1*)
  97     {
  98         assert(false);
  99     }
 100     catch (const C2*)
 101     {
 102         assert(false);
 103     }
 104     catch (const B*)
 105     {
 106         assert(false);
 107     }
 108 }
 109
 110 void f3()
 111 {
 112     try
 113     {
 114         f2();
 115         assert(false);
 116     }
 117     catch (const B* a)  // can catch B
 118     {
 119         assert(static_cast<const B*>(a)->id_ == 8);
 120         throw;
 121     }
 122     catch (const C1* c1)
 123     {
 124         assert(false);
 125     }
 126     catch (const C2*)
 127     {
 128         assert(false);
 129     }
 130 }
 131
 132 void f4()
 133 {
 134     try
 135     {
 136         f3();
 137         assert(false);
 138     }
 139     catch (const C2* c2)  // can catch C2
 140     {
 141         assert(c2->id_ == 3);
 142         throw;
 143     }
 144     catch (const B* a)
 145     {
 146         assert(false);
 147     }
 148     catch (const C1*)
 149     {
 150         assert(false);
 151     }
 152 }
 153
 154 void f5()
 155 {
 156     try
 157     {
 158         f4();
 159         assert(false);
 160     }
 161     catch (const C1* c1)  // can catch C1
 162     {
 163         assert(c1->id_ == 4);
 164         assert(static_cast<const B*>(c1)->id_ == 8);
 165         throw;
 166     }
 167     catch (const B* a)
 168     {
 169         assert(false);
 170     }
 171     catch (const C2*)
 172     {
 173         assert(false);
 174     }
 175 }
 176
 177 int main(int, char**)
 178 {
 179     try
 180     {
 181         f5();
 182         assert(false);
 183     }
 184     catch (...)
 185     {
 186     }
 187
 188     return 0;
 189 }