|
150
|
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
|
|
173
|
15 // UNSUPPORTED: no-exceptions
|
|
150
|
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 }
|
