]>
Commit | Line | Data |
---|---|---|
31f18b77 FG |
1 | // Copyright 2010, Google Inc. |
2 | // All rights reserved. | |
3 | // | |
4 | // Redistribution and use in source and binary forms, with or without | |
5 | // modification, are permitted provided that the following conditions are | |
6 | // met: | |
7 | // | |
8 | // * Redistributions of source code must retain the above copyright | |
9 | // notice, this list of conditions and the following disclaimer. | |
10 | // * Redistributions in binary form must reproduce the above | |
11 | // copyright notice, this list of conditions and the following disclaimer | |
12 | // in the documentation and/or other materials provided with the | |
13 | // distribution. | |
14 | // * Neither the name of Google Inc. nor the names of its | |
15 | // contributors may be used to endorse or promote products derived from | |
16 | // this software without specific prior written permission. | |
17 | // | |
18 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
19 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
20 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
21 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
22 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
23 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
24 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
25 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
26 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
27 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
28 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
29 | // | |
30 | // Author: vladl@google.com (Vlad Losev) | |
31 | // | |
32 | // Tests for Google Test itself. Tests in this file throw C++ or SEH | |
33 | // exceptions, and the output is verified by gtest_catch_exceptions_test.py. | |
34 | ||
35 | #include "gtest/gtest.h" | |
36 | ||
37 | #include <stdio.h> // NOLINT | |
38 | #include <stdlib.h> // For exit(). | |
39 | ||
40 | #if GTEST_HAS_SEH | |
41 | # include <windows.h> | |
42 | #endif | |
43 | ||
44 | #if GTEST_HAS_EXCEPTIONS | |
45 | # include <exception> // For set_terminate(). | |
46 | # include <stdexcept> | |
47 | #endif | |
48 | ||
49 | using testing::Test; | |
50 | ||
51 | #if GTEST_HAS_SEH | |
52 | ||
53 | class SehExceptionInConstructorTest : public Test { | |
54 | public: | |
55 | SehExceptionInConstructorTest() { RaiseException(42, 0, 0, NULL); } | |
56 | }; | |
57 | ||
58 | TEST_F(SehExceptionInConstructorTest, ThrowsExceptionInConstructor) {} | |
59 | ||
60 | class SehExceptionInDestructorTest : public Test { | |
61 | public: | |
62 | ~SehExceptionInDestructorTest() { RaiseException(42, 0, 0, NULL); } | |
63 | }; | |
64 | ||
65 | TEST_F(SehExceptionInDestructorTest, ThrowsExceptionInDestructor) {} | |
66 | ||
67 | class SehExceptionInSetUpTestCaseTest : public Test { | |
68 | public: | |
69 | static void SetUpTestCase() { RaiseException(42, 0, 0, NULL); } | |
70 | }; | |
71 | ||
72 | TEST_F(SehExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {} | |
73 | ||
74 | class SehExceptionInTearDownTestCaseTest : public Test { | |
75 | public: | |
76 | static void TearDownTestCase() { RaiseException(42, 0, 0, NULL); } | |
77 | }; | |
78 | ||
79 | TEST_F(SehExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {} | |
80 | ||
81 | class SehExceptionInSetUpTest : public Test { | |
82 | protected: | |
83 | virtual void SetUp() { RaiseException(42, 0, 0, NULL); } | |
84 | }; | |
85 | ||
86 | TEST_F(SehExceptionInSetUpTest, ThrowsExceptionInSetUp) {} | |
87 | ||
88 | class SehExceptionInTearDownTest : public Test { | |
89 | protected: | |
90 | virtual void TearDown() { RaiseException(42, 0, 0, NULL); } | |
91 | }; | |
92 | ||
93 | TEST_F(SehExceptionInTearDownTest, ThrowsExceptionInTearDown) {} | |
94 | ||
95 | TEST(SehExceptionTest, ThrowsSehException) { | |
96 | RaiseException(42, 0, 0, NULL); | |
97 | } | |
98 | ||
99 | #endif // GTEST_HAS_SEH | |
100 | ||
101 | #if GTEST_HAS_EXCEPTIONS | |
102 | ||
103 | class CxxExceptionInConstructorTest : public Test { | |
104 | public: | |
105 | CxxExceptionInConstructorTest() { | |
106 | // Without this macro VC++ complains about unreachable code at the end of | |
107 | // the constructor. | |
108 | GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_( | |
109 | throw std::runtime_error("Standard C++ exception")); | |
110 | } | |
111 | ||
112 | static void TearDownTestCase() { | |
113 | printf("%s", | |
114 | "CxxExceptionInConstructorTest::TearDownTestCase() " | |
115 | "called as expected.\n"); | |
116 | } | |
117 | ||
118 | protected: | |
119 | ~CxxExceptionInConstructorTest() { | |
120 | ADD_FAILURE() << "CxxExceptionInConstructorTest destructor " | |
121 | << "called unexpectedly."; | |
122 | } | |
123 | ||
124 | virtual void SetUp() { | |
125 | ADD_FAILURE() << "CxxExceptionInConstructorTest::SetUp() " | |
126 | << "called unexpectedly."; | |
127 | } | |
128 | ||
129 | virtual void TearDown() { | |
130 | ADD_FAILURE() << "CxxExceptionInConstructorTest::TearDown() " | |
131 | << "called unexpectedly."; | |
132 | } | |
133 | }; | |
134 | ||
135 | TEST_F(CxxExceptionInConstructorTest, ThrowsExceptionInConstructor) { | |
136 | ADD_FAILURE() << "CxxExceptionInConstructorTest test body " | |
137 | << "called unexpectedly."; | |
138 | } | |
139 | ||
140 | // Exceptions in destructors are not supported in C++11. | |
141 | #if !defined(__GXX_EXPERIMENTAL_CXX0X__) && __cplusplus < 201103L | |
142 | class CxxExceptionInDestructorTest : public Test { | |
143 | public: | |
144 | static void TearDownTestCase() { | |
145 | printf("%s", | |
146 | "CxxExceptionInDestructorTest::TearDownTestCase() " | |
147 | "called as expected.\n"); | |
148 | } | |
149 | ||
150 | protected: | |
151 | ~CxxExceptionInDestructorTest() { | |
152 | GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_( | |
153 | throw std::runtime_error("Standard C++ exception")); | |
154 | } | |
155 | }; | |
156 | ||
157 | TEST_F(CxxExceptionInDestructorTest, ThrowsExceptionInDestructor) {} | |
158 | #endif // C++11 mode | |
159 | ||
160 | class CxxExceptionInSetUpTestCaseTest : public Test { | |
161 | public: | |
162 | CxxExceptionInSetUpTestCaseTest() { | |
163 | printf("%s", | |
164 | "CxxExceptionInSetUpTestCaseTest constructor " | |
165 | "called as expected.\n"); | |
166 | } | |
167 | ||
168 | static void SetUpTestCase() { | |
169 | throw std::runtime_error("Standard C++ exception"); | |
170 | } | |
171 | ||
172 | static void TearDownTestCase() { | |
173 | printf("%s", | |
174 | "CxxExceptionInSetUpTestCaseTest::TearDownTestCase() " | |
175 | "called as expected.\n"); | |
176 | } | |
177 | ||
178 | protected: | |
179 | ~CxxExceptionInSetUpTestCaseTest() { | |
180 | printf("%s", | |
181 | "CxxExceptionInSetUpTestCaseTest destructor " | |
182 | "called as expected.\n"); | |
183 | } | |
184 | ||
185 | virtual void SetUp() { | |
186 | printf("%s", | |
187 | "CxxExceptionInSetUpTestCaseTest::SetUp() " | |
188 | "called as expected.\n"); | |
189 | } | |
190 | ||
191 | virtual void TearDown() { | |
192 | printf("%s", | |
193 | "CxxExceptionInSetUpTestCaseTest::TearDown() " | |
194 | "called as expected.\n"); | |
195 | } | |
196 | }; | |
197 | ||
198 | TEST_F(CxxExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) { | |
199 | printf("%s", | |
200 | "CxxExceptionInSetUpTestCaseTest test body " | |
201 | "called as expected.\n"); | |
202 | } | |
203 | ||
204 | class CxxExceptionInTearDownTestCaseTest : public Test { | |
205 | public: | |
206 | static void TearDownTestCase() { | |
207 | throw std::runtime_error("Standard C++ exception"); | |
208 | } | |
209 | }; | |
210 | ||
211 | TEST_F(CxxExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {} | |
212 | ||
213 | class CxxExceptionInSetUpTest : public Test { | |
214 | public: | |
215 | static void TearDownTestCase() { | |
216 | printf("%s", | |
217 | "CxxExceptionInSetUpTest::TearDownTestCase() " | |
218 | "called as expected.\n"); | |
219 | } | |
220 | ||
221 | protected: | |
222 | ~CxxExceptionInSetUpTest() { | |
223 | printf("%s", | |
224 | "CxxExceptionInSetUpTest destructor " | |
225 | "called as expected.\n"); | |
226 | } | |
227 | ||
228 | virtual void SetUp() { throw std::runtime_error("Standard C++ exception"); } | |
229 | ||
230 | virtual void TearDown() { | |
231 | printf("%s", | |
232 | "CxxExceptionInSetUpTest::TearDown() " | |
233 | "called as expected.\n"); | |
234 | } | |
235 | }; | |
236 | ||
237 | TEST_F(CxxExceptionInSetUpTest, ThrowsExceptionInSetUp) { | |
238 | ADD_FAILURE() << "CxxExceptionInSetUpTest test body " | |
239 | << "called unexpectedly."; | |
240 | } | |
241 | ||
242 | class CxxExceptionInTearDownTest : public Test { | |
243 | public: | |
244 | static void TearDownTestCase() { | |
245 | printf("%s", | |
246 | "CxxExceptionInTearDownTest::TearDownTestCase() " | |
247 | "called as expected.\n"); | |
248 | } | |
249 | ||
250 | protected: | |
251 | ~CxxExceptionInTearDownTest() { | |
252 | printf("%s", | |
253 | "CxxExceptionInTearDownTest destructor " | |
254 | "called as expected.\n"); | |
255 | } | |
256 | ||
257 | virtual void TearDown() { | |
258 | throw std::runtime_error("Standard C++ exception"); | |
259 | } | |
260 | }; | |
261 | ||
262 | TEST_F(CxxExceptionInTearDownTest, ThrowsExceptionInTearDown) {} | |
263 | ||
264 | class CxxExceptionInTestBodyTest : public Test { | |
265 | public: | |
266 | static void TearDownTestCase() { | |
267 | printf("%s", | |
268 | "CxxExceptionInTestBodyTest::TearDownTestCase() " | |
269 | "called as expected.\n"); | |
270 | } | |
271 | ||
272 | protected: | |
273 | ~CxxExceptionInTestBodyTest() { | |
274 | printf("%s", | |
275 | "CxxExceptionInTestBodyTest destructor " | |
276 | "called as expected.\n"); | |
277 | } | |
278 | ||
279 | virtual void TearDown() { | |
280 | printf("%s", | |
281 | "CxxExceptionInTestBodyTest::TearDown() " | |
282 | "called as expected.\n"); | |
283 | } | |
284 | }; | |
285 | ||
286 | TEST_F(CxxExceptionInTestBodyTest, ThrowsStdCxxException) { | |
287 | throw std::runtime_error("Standard C++ exception"); | |
288 | } | |
289 | ||
290 | TEST(CxxExceptionTest, ThrowsNonStdCxxException) { | |
291 | throw "C-string"; | |
292 | } | |
293 | ||
294 | // This terminate handler aborts the program using exit() rather than abort(). | |
295 | // This avoids showing pop-ups on Windows systems and core dumps on Unix-like | |
296 | // ones. | |
297 | void TerminateHandler() { | |
298 | fprintf(stderr, "%s\n", "Unhandled C++ exception terminating the program."); | |
299 | fflush(NULL); | |
300 | exit(3); | |
301 | } | |
302 | ||
303 | #endif // GTEST_HAS_EXCEPTIONS | |
304 | ||
305 | int main(int argc, char** argv) { | |
306 | #if GTEST_HAS_EXCEPTIONS | |
307 | std::set_terminate(&TerminateHandler); | |
308 | #endif | |
309 | testing::InitGoogleTest(&argc, argv); | |
310 | return RUN_ALL_TESTS(); | |
311 | } |