1 |
2 |
jamieiles |
// Copyright 2005, 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: wan@google.com (Zhanyong Wan)
|
31 |
|
|
//
|
32 |
|
|
// Tests for death tests.
|
33 |
|
|
|
34 |
|
|
#include "gtest/gtest-death-test.h"
|
35 |
|
|
#include "gtest/gtest.h"
|
36 |
|
|
#include "gtest/internal/gtest-filepath.h"
|
37 |
|
|
|
38 |
|
|
using testing::internal::AlwaysFalse;
|
39 |
|
|
using testing::internal::AlwaysTrue;
|
40 |
|
|
|
41 |
|
|
#if GTEST_HAS_DEATH_TEST
|
42 |
|
|
|
43 |
|
|
# if GTEST_OS_WINDOWS
|
44 |
|
|
# include <direct.h> // For chdir().
|
45 |
|
|
# else
|
46 |
|
|
# include <unistd.h>
|
47 |
|
|
# include <sys/wait.h> // For waitpid.
|
48 |
|
|
# endif // GTEST_OS_WINDOWS
|
49 |
|
|
|
50 |
|
|
# include <limits.h>
|
51 |
|
|
# include <signal.h>
|
52 |
|
|
# include <stdio.h>
|
53 |
|
|
|
54 |
|
|
# if GTEST_OS_LINUX
|
55 |
|
|
# include <sys/time.h>
|
56 |
|
|
# endif // GTEST_OS_LINUX
|
57 |
|
|
|
58 |
|
|
# include "gtest/gtest-spi.h"
|
59 |
|
|
|
60 |
|
|
// Indicates that this translation unit is part of Google Test's
|
61 |
|
|
// implementation. It must come before gtest-internal-inl.h is
|
62 |
|
|
// included, or there will be a compiler error. This trick is to
|
63 |
|
|
// prevent a user from accidentally including gtest-internal-inl.h in
|
64 |
|
|
// his code.
|
65 |
|
|
# define GTEST_IMPLEMENTATION_ 1
|
66 |
|
|
# include "src/gtest-internal-inl.h"
|
67 |
|
|
# undef GTEST_IMPLEMENTATION_
|
68 |
|
|
|
69 |
|
|
namespace posix = ::testing::internal::posix;
|
70 |
|
|
|
71 |
|
|
using testing::Message;
|
72 |
|
|
using testing::internal::DeathTest;
|
73 |
|
|
using testing::internal::DeathTestFactory;
|
74 |
|
|
using testing::internal::FilePath;
|
75 |
|
|
using testing::internal::GetLastErrnoDescription;
|
76 |
|
|
using testing::internal::GetUnitTestImpl;
|
77 |
|
|
using testing::internal::InDeathTestChild;
|
78 |
|
|
using testing::internal::ParseNaturalNumber;
|
79 |
|
|
|
80 |
|
|
namespace testing {
|
81 |
|
|
namespace internal {
|
82 |
|
|
|
83 |
|
|
// A helper class whose objects replace the death test factory for a
|
84 |
|
|
// single UnitTest object during their lifetimes.
|
85 |
|
|
class ReplaceDeathTestFactory {
|
86 |
|
|
public:
|
87 |
|
|
explicit ReplaceDeathTestFactory(DeathTestFactory* new_factory)
|
88 |
|
|
: unit_test_impl_(GetUnitTestImpl()) {
|
89 |
|
|
old_factory_ = unit_test_impl_->death_test_factory_.release();
|
90 |
|
|
unit_test_impl_->death_test_factory_.reset(new_factory);
|
91 |
|
|
}
|
92 |
|
|
|
93 |
|
|
~ReplaceDeathTestFactory() {
|
94 |
|
|
unit_test_impl_->death_test_factory_.release();
|
95 |
|
|
unit_test_impl_->death_test_factory_.reset(old_factory_);
|
96 |
|
|
}
|
97 |
|
|
private:
|
98 |
|
|
// Prevents copying ReplaceDeathTestFactory objects.
|
99 |
|
|
ReplaceDeathTestFactory(const ReplaceDeathTestFactory&);
|
100 |
|
|
void operator=(const ReplaceDeathTestFactory&);
|
101 |
|
|
|
102 |
|
|
UnitTestImpl* unit_test_impl_;
|
103 |
|
|
DeathTestFactory* old_factory_;
|
104 |
|
|
};
|
105 |
|
|
|
106 |
|
|
} // namespace internal
|
107 |
|
|
} // namespace testing
|
108 |
|
|
|
109 |
|
|
void DieWithMessage(const ::std::string& message) {
|
110 |
|
|
fprintf(stderr, "%s", message.c_str());
|
111 |
|
|
fflush(stderr); // Make sure the text is printed before the process exits.
|
112 |
|
|
|
113 |
|
|
// We call _exit() instead of exit(), as the former is a direct
|
114 |
|
|
// system call and thus safer in the presence of threads. exit()
|
115 |
|
|
// will invoke user-defined exit-hooks, which may do dangerous
|
116 |
|
|
// things that conflict with death tests.
|
117 |
|
|
//
|
118 |
|
|
// Some compilers can recognize that _exit() never returns and issue the
|
119 |
|
|
// 'unreachable code' warning for code following this function, unless
|
120 |
|
|
// fooled by a fake condition.
|
121 |
|
|
if (AlwaysTrue())
|
122 |
|
|
_exit(1);
|
123 |
|
|
}
|
124 |
|
|
|
125 |
|
|
void DieInside(const ::std::string& function) {
|
126 |
|
|
DieWithMessage("death inside " + function + "().");
|
127 |
|
|
}
|
128 |
|
|
|
129 |
|
|
// Tests that death tests work.
|
130 |
|
|
|
131 |
|
|
class TestForDeathTest : public testing::Test {
|
132 |
|
|
protected:
|
133 |
|
|
TestForDeathTest() : original_dir_(FilePath::GetCurrentDir()) {}
|
134 |
|
|
|
135 |
|
|
virtual ~TestForDeathTest() {
|
136 |
|
|
posix::ChDir(original_dir_.c_str());
|
137 |
|
|
}
|
138 |
|
|
|
139 |
|
|
// A static member function that's expected to die.
|
140 |
|
|
static void StaticMemberFunction() { DieInside("StaticMemberFunction"); }
|
141 |
|
|
|
142 |
|
|
// A method of the test fixture that may die.
|
143 |
|
|
void MemberFunction() {
|
144 |
|
|
if (should_die_)
|
145 |
|
|
DieInside("MemberFunction");
|
146 |
|
|
}
|
147 |
|
|
|
148 |
|
|
// True iff MemberFunction() should die.
|
149 |
|
|
bool should_die_;
|
150 |
|
|
const FilePath original_dir_;
|
151 |
|
|
};
|
152 |
|
|
|
153 |
|
|
// A class with a member function that may die.
|
154 |
|
|
class MayDie {
|
155 |
|
|
public:
|
156 |
|
|
explicit MayDie(bool should_die) : should_die_(should_die) {}
|
157 |
|
|
|
158 |
|
|
// A member function that may die.
|
159 |
|
|
void MemberFunction() const {
|
160 |
|
|
if (should_die_)
|
161 |
|
|
DieInside("MayDie::MemberFunction");
|
162 |
|
|
}
|
163 |
|
|
|
164 |
|
|
private:
|
165 |
|
|
// True iff MemberFunction() should die.
|
166 |
|
|
bool should_die_;
|
167 |
|
|
};
|
168 |
|
|
|
169 |
|
|
// A global function that's expected to die.
|
170 |
|
|
void GlobalFunction() { DieInside("GlobalFunction"); }
|
171 |
|
|
|
172 |
|
|
// A non-void function that's expected to die.
|
173 |
|
|
int NonVoidFunction() {
|
174 |
|
|
DieInside("NonVoidFunction");
|
175 |
|
|
return 1;
|
176 |
|
|
}
|
177 |
|
|
|
178 |
|
|
// A unary function that may die.
|
179 |
|
|
void DieIf(bool should_die) {
|
180 |
|
|
if (should_die)
|
181 |
|
|
DieInside("DieIf");
|
182 |
|
|
}
|
183 |
|
|
|
184 |
|
|
// A binary function that may die.
|
185 |
|
|
bool DieIfLessThan(int x, int y) {
|
186 |
|
|
if (x < y) {
|
187 |
|
|
DieInside("DieIfLessThan");
|
188 |
|
|
}
|
189 |
|
|
return true;
|
190 |
|
|
}
|
191 |
|
|
|
192 |
|
|
// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
|
193 |
|
|
void DeathTestSubroutine() {
|
194 |
|
|
EXPECT_DEATH(GlobalFunction(), "death.*GlobalFunction");
|
195 |
|
|
ASSERT_DEATH(GlobalFunction(), "death.*GlobalFunction");
|
196 |
|
|
}
|
197 |
|
|
|
198 |
|
|
// Death in dbg, not opt.
|
199 |
|
|
int DieInDebugElse12(int* sideeffect) {
|
200 |
|
|
if (sideeffect) *sideeffect = 12;
|
201 |
|
|
|
202 |
|
|
# ifndef NDEBUG
|
203 |
|
|
|
204 |
|
|
DieInside("DieInDebugElse12");
|
205 |
|
|
|
206 |
|
|
# endif // NDEBUG
|
207 |
|
|
|
208 |
|
|
return 12;
|
209 |
|
|
}
|
210 |
|
|
|
211 |
|
|
# if GTEST_OS_WINDOWS
|
212 |
|
|
|
213 |
|
|
// Tests the ExitedWithCode predicate.
|
214 |
|
|
TEST(ExitStatusPredicateTest, ExitedWithCode) {
|
215 |
|
|
// On Windows, the process's exit code is the same as its exit status,
|
216 |
|
|
// so the predicate just compares the its input with its parameter.
|
217 |
|
|
EXPECT_TRUE(testing::ExitedWithCode(0)(0));
|
218 |
|
|
EXPECT_TRUE(testing::ExitedWithCode(1)(1));
|
219 |
|
|
EXPECT_TRUE(testing::ExitedWithCode(42)(42));
|
220 |
|
|
EXPECT_FALSE(testing::ExitedWithCode(0)(1));
|
221 |
|
|
EXPECT_FALSE(testing::ExitedWithCode(1)(0));
|
222 |
|
|
}
|
223 |
|
|
|
224 |
|
|
# else
|
225 |
|
|
|
226 |
|
|
// Returns the exit status of a process that calls _exit(2) with a
|
227 |
|
|
// given exit code. This is a helper function for the
|
228 |
|
|
// ExitStatusPredicateTest test suite.
|
229 |
|
|
static int NormalExitStatus(int exit_code) {
|
230 |
|
|
pid_t child_pid = fork();
|
231 |
|
|
if (child_pid == 0) {
|
232 |
|
|
_exit(exit_code);
|
233 |
|
|
}
|
234 |
|
|
int status;
|
235 |
|
|
waitpid(child_pid, &status, 0);
|
236 |
|
|
return status;
|
237 |
|
|
}
|
238 |
|
|
|
239 |
|
|
// Returns the exit status of a process that raises a given signal.
|
240 |
|
|
// If the signal does not cause the process to die, then it returns
|
241 |
|
|
// instead the exit status of a process that exits normally with exit
|
242 |
|
|
// code 1. This is a helper function for the ExitStatusPredicateTest
|
243 |
|
|
// test suite.
|
244 |
|
|
static int KilledExitStatus(int signum) {
|
245 |
|
|
pid_t child_pid = fork();
|
246 |
|
|
if (child_pid == 0) {
|
247 |
|
|
raise(signum);
|
248 |
|
|
_exit(1);
|
249 |
|
|
}
|
250 |
|
|
int status;
|
251 |
|
|
waitpid(child_pid, &status, 0);
|
252 |
|
|
return status;
|
253 |
|
|
}
|
254 |
|
|
|
255 |
|
|
// Tests the ExitedWithCode predicate.
|
256 |
|
|
TEST(ExitStatusPredicateTest, ExitedWithCode) {
|
257 |
|
|
const int status0 = NormalExitStatus(0);
|
258 |
|
|
const int status1 = NormalExitStatus(1);
|
259 |
|
|
const int status42 = NormalExitStatus(42);
|
260 |
|
|
const testing::ExitedWithCode pred0(0);
|
261 |
|
|
const testing::ExitedWithCode pred1(1);
|
262 |
|
|
const testing::ExitedWithCode pred42(42);
|
263 |
|
|
EXPECT_PRED1(pred0, status0);
|
264 |
|
|
EXPECT_PRED1(pred1, status1);
|
265 |
|
|
EXPECT_PRED1(pred42, status42);
|
266 |
|
|
EXPECT_FALSE(pred0(status1));
|
267 |
|
|
EXPECT_FALSE(pred42(status0));
|
268 |
|
|
EXPECT_FALSE(pred1(status42));
|
269 |
|
|
}
|
270 |
|
|
|
271 |
|
|
// Tests the KilledBySignal predicate.
|
272 |
|
|
TEST(ExitStatusPredicateTest, KilledBySignal) {
|
273 |
|
|
const int status_segv = KilledExitStatus(SIGSEGV);
|
274 |
|
|
const int status_kill = KilledExitStatus(SIGKILL);
|
275 |
|
|
const testing::KilledBySignal pred_segv(SIGSEGV);
|
276 |
|
|
const testing::KilledBySignal pred_kill(SIGKILL);
|
277 |
|
|
EXPECT_PRED1(pred_segv, status_segv);
|
278 |
|
|
EXPECT_PRED1(pred_kill, status_kill);
|
279 |
|
|
EXPECT_FALSE(pred_segv(status_kill));
|
280 |
|
|
EXPECT_FALSE(pred_kill(status_segv));
|
281 |
|
|
}
|
282 |
|
|
|
283 |
|
|
# endif // GTEST_OS_WINDOWS
|
284 |
|
|
|
285 |
|
|
// Tests that the death test macros expand to code which may or may not
|
286 |
|
|
// be followed by operator<<, and that in either case the complete text
|
287 |
|
|
// comprises only a single C++ statement.
|
288 |
|
|
TEST_F(TestForDeathTest, SingleStatement) {
|
289 |
|
|
if (AlwaysFalse())
|
290 |
|
|
// This would fail if executed; this is a compilation test only
|
291 |
|
|
ASSERT_DEATH(return, "");
|
292 |
|
|
|
293 |
|
|
if (AlwaysTrue())
|
294 |
|
|
EXPECT_DEATH(_exit(1), "");
|
295 |
|
|
else
|
296 |
|
|
// This empty "else" branch is meant to ensure that EXPECT_DEATH
|
297 |
|
|
// doesn't expand into an "if" statement without an "else"
|
298 |
|
|
;
|
299 |
|
|
|
300 |
|
|
if (AlwaysFalse())
|
301 |
|
|
ASSERT_DEATH(return, "") << "did not die";
|
302 |
|
|
|
303 |
|
|
if (AlwaysFalse())
|
304 |
|
|
;
|
305 |
|
|
else
|
306 |
|
|
EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3;
|
307 |
|
|
}
|
308 |
|
|
|
309 |
|
|
void DieWithEmbeddedNul() {
|
310 |
|
|
fprintf(stderr, "Hello%cmy null world.\n", '\0');
|
311 |
|
|
fflush(stderr);
|
312 |
|
|
_exit(1);
|
313 |
|
|
}
|
314 |
|
|
|
315 |
|
|
# if GTEST_USES_PCRE
|
316 |
|
|
// Tests that EXPECT_DEATH and ASSERT_DEATH work when the error
|
317 |
|
|
// message has a NUL character in it.
|
318 |
|
|
TEST_F(TestForDeathTest, EmbeddedNulInMessage) {
|
319 |
|
|
// TODO(wan@google.com): <regex.h> doesn't support matching strings
|
320 |
|
|
// with embedded NUL characters - find a way to workaround it.
|
321 |
|
|
EXPECT_DEATH(DieWithEmbeddedNul(), "my null world");
|
322 |
|
|
ASSERT_DEATH(DieWithEmbeddedNul(), "my null world");
|
323 |
|
|
}
|
324 |
|
|
# endif // GTEST_USES_PCRE
|
325 |
|
|
|
326 |
|
|
// Tests that death test macros expand to code which interacts well with switch
|
327 |
|
|
// statements.
|
328 |
|
|
TEST_F(TestForDeathTest, SwitchStatement) {
|
329 |
|
|
// Microsoft compiler usually complains about switch statements without
|
330 |
|
|
// case labels. We suppress that warning for this test.
|
331 |
|
|
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065)
|
332 |
|
|
|
333 |
|
|
switch (0)
|
334 |
|
|
default:
|
335 |
|
|
ASSERT_DEATH(_exit(1), "") << "exit in default switch handler";
|
336 |
|
|
|
337 |
|
|
switch (0)
|
338 |
|
|
case 0:
|
339 |
|
|
EXPECT_DEATH(_exit(1), "") << "exit in switch case";
|
340 |
|
|
|
341 |
|
|
GTEST_DISABLE_MSC_WARNINGS_POP_()
|
342 |
|
|
}
|
343 |
|
|
|
344 |
|
|
// Tests that a static member function can be used in a "fast" style
|
345 |
|
|
// death test.
|
346 |
|
|
TEST_F(TestForDeathTest, StaticMemberFunctionFastStyle) {
|
347 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
348 |
|
|
ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
|
349 |
|
|
}
|
350 |
|
|
|
351 |
|
|
// Tests that a method of the test fixture can be used in a "fast"
|
352 |
|
|
// style death test.
|
353 |
|
|
TEST_F(TestForDeathTest, MemberFunctionFastStyle) {
|
354 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
355 |
|
|
should_die_ = true;
|
356 |
|
|
EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
|
357 |
|
|
}
|
358 |
|
|
|
359 |
|
|
void ChangeToRootDir() { posix::ChDir(GTEST_PATH_SEP_); }
|
360 |
|
|
|
361 |
|
|
// Tests that death tests work even if the current directory has been
|
362 |
|
|
// changed.
|
363 |
|
|
TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
|
364 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
365 |
|
|
|
366 |
|
|
ChangeToRootDir();
|
367 |
|
|
EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
|
368 |
|
|
|
369 |
|
|
ChangeToRootDir();
|
370 |
|
|
ASSERT_DEATH(_exit(1), "");
|
371 |
|
|
}
|
372 |
|
|
|
373 |
|
|
# if GTEST_OS_LINUX
|
374 |
|
|
void SigprofAction(int, siginfo_t*, void*) { /* no op */ }
|
375 |
|
|
|
376 |
|
|
// Sets SIGPROF action and ITIMER_PROF timer (interval: 1ms).
|
377 |
|
|
void SetSigprofActionAndTimer() {
|
378 |
|
|
struct itimerval timer;
|
379 |
|
|
timer.it_interval.tv_sec = 0;
|
380 |
|
|
timer.it_interval.tv_usec = 1;
|
381 |
|
|
timer.it_value = timer.it_interval;
|
382 |
|
|
ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
|
383 |
|
|
struct sigaction signal_action;
|
384 |
|
|
memset(&signal_action, 0, sizeof(signal_action));
|
385 |
|
|
sigemptyset(&signal_action.sa_mask);
|
386 |
|
|
signal_action.sa_sigaction = SigprofAction;
|
387 |
|
|
signal_action.sa_flags = SA_RESTART | SA_SIGINFO;
|
388 |
|
|
ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, NULL));
|
389 |
|
|
}
|
390 |
|
|
|
391 |
|
|
// Disables ITIMER_PROF timer and ignores SIGPROF signal.
|
392 |
|
|
void DisableSigprofActionAndTimer(struct sigaction* old_signal_action) {
|
393 |
|
|
struct itimerval timer;
|
394 |
|
|
timer.it_interval.tv_sec = 0;
|
395 |
|
|
timer.it_interval.tv_usec = 0;
|
396 |
|
|
timer.it_value = timer.it_interval;
|
397 |
|
|
ASSERT_EQ(0, setitimer(ITIMER_PROF, &timer, NULL));
|
398 |
|
|
struct sigaction signal_action;
|
399 |
|
|
memset(&signal_action, 0, sizeof(signal_action));
|
400 |
|
|
sigemptyset(&signal_action.sa_mask);
|
401 |
|
|
signal_action.sa_handler = SIG_IGN;
|
402 |
|
|
ASSERT_EQ(0, sigaction(SIGPROF, &signal_action, old_signal_action));
|
403 |
|
|
}
|
404 |
|
|
|
405 |
|
|
// Tests that death tests work when SIGPROF handler and timer are set.
|
406 |
|
|
TEST_F(TestForDeathTest, FastSigprofActionSet) {
|
407 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
408 |
|
|
SetSigprofActionAndTimer();
|
409 |
|
|
EXPECT_DEATH(_exit(1), "");
|
410 |
|
|
struct sigaction old_signal_action;
|
411 |
|
|
DisableSigprofActionAndTimer(&old_signal_action);
|
412 |
|
|
EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
|
413 |
|
|
}
|
414 |
|
|
|
415 |
|
|
TEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) {
|
416 |
|
|
testing::GTEST_FLAG(death_test_style) = "threadsafe";
|
417 |
|
|
SetSigprofActionAndTimer();
|
418 |
|
|
EXPECT_DEATH(_exit(1), "");
|
419 |
|
|
struct sigaction old_signal_action;
|
420 |
|
|
DisableSigprofActionAndTimer(&old_signal_action);
|
421 |
|
|
EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
|
422 |
|
|
}
|
423 |
|
|
# endif // GTEST_OS_LINUX
|
424 |
|
|
|
425 |
|
|
// Repeats a representative sample of death tests in the "threadsafe" style:
|
426 |
|
|
|
427 |
|
|
TEST_F(TestForDeathTest, StaticMemberFunctionThreadsafeStyle) {
|
428 |
|
|
testing::GTEST_FLAG(death_test_style) = "threadsafe";
|
429 |
|
|
ASSERT_DEATH(StaticMemberFunction(), "death.*StaticMember");
|
430 |
|
|
}
|
431 |
|
|
|
432 |
|
|
TEST_F(TestForDeathTest, MemberFunctionThreadsafeStyle) {
|
433 |
|
|
testing::GTEST_FLAG(death_test_style) = "threadsafe";
|
434 |
|
|
should_die_ = true;
|
435 |
|
|
EXPECT_DEATH(MemberFunction(), "inside.*MemberFunction");
|
436 |
|
|
}
|
437 |
|
|
|
438 |
|
|
TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {
|
439 |
|
|
testing::GTEST_FLAG(death_test_style) = "threadsafe";
|
440 |
|
|
|
441 |
|
|
for (int i = 0; i < 3; ++i)
|
442 |
|
|
EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i;
|
443 |
|
|
}
|
444 |
|
|
|
445 |
|
|
TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
|
446 |
|
|
testing::GTEST_FLAG(death_test_style) = "threadsafe";
|
447 |
|
|
|
448 |
|
|
ChangeToRootDir();
|
449 |
|
|
EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
|
450 |
|
|
|
451 |
|
|
ChangeToRootDir();
|
452 |
|
|
ASSERT_DEATH(_exit(1), "");
|
453 |
|
|
}
|
454 |
|
|
|
455 |
|
|
TEST_F(TestForDeathTest, MixedStyles) {
|
456 |
|
|
testing::GTEST_FLAG(death_test_style) = "threadsafe";
|
457 |
|
|
EXPECT_DEATH(_exit(1), "");
|
458 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
459 |
|
|
EXPECT_DEATH(_exit(1), "");
|
460 |
|
|
}
|
461 |
|
|
|
462 |
|
|
# if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
|
463 |
|
|
|
464 |
|
|
namespace {
|
465 |
|
|
|
466 |
|
|
bool pthread_flag;
|
467 |
|
|
|
468 |
|
|
void SetPthreadFlag() {
|
469 |
|
|
pthread_flag = true;
|
470 |
|
|
}
|
471 |
|
|
|
472 |
|
|
} // namespace
|
473 |
|
|
|
474 |
|
|
TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
|
475 |
|
|
if (!testing::GTEST_FLAG(death_test_use_fork)) {
|
476 |
|
|
testing::GTEST_FLAG(death_test_style) = "threadsafe";
|
477 |
|
|
pthread_flag = false;
|
478 |
|
|
ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, NULL, NULL));
|
479 |
|
|
ASSERT_DEATH(_exit(1), "");
|
480 |
|
|
ASSERT_FALSE(pthread_flag);
|
481 |
|
|
}
|
482 |
|
|
}
|
483 |
|
|
|
484 |
|
|
# endif // GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
|
485 |
|
|
|
486 |
|
|
// Tests that a method of another class can be used in a death test.
|
487 |
|
|
TEST_F(TestForDeathTest, MethodOfAnotherClass) {
|
488 |
|
|
const MayDie x(true);
|
489 |
|
|
ASSERT_DEATH(x.MemberFunction(), "MayDie\\:\\:MemberFunction");
|
490 |
|
|
}
|
491 |
|
|
|
492 |
|
|
// Tests that a global function can be used in a death test.
|
493 |
|
|
TEST_F(TestForDeathTest, GlobalFunction) {
|
494 |
|
|
EXPECT_DEATH(GlobalFunction(), "GlobalFunction");
|
495 |
|
|
}
|
496 |
|
|
|
497 |
|
|
// Tests that any value convertible to an RE works as a second
|
498 |
|
|
// argument to EXPECT_DEATH.
|
499 |
|
|
TEST_F(TestForDeathTest, AcceptsAnythingConvertibleToRE) {
|
500 |
|
|
static const char regex_c_str[] = "GlobalFunction";
|
501 |
|
|
EXPECT_DEATH(GlobalFunction(), regex_c_str);
|
502 |
|
|
|
503 |
|
|
const testing::internal::RE regex(regex_c_str);
|
504 |
|
|
EXPECT_DEATH(GlobalFunction(), regex);
|
505 |
|
|
|
506 |
|
|
# if GTEST_HAS_GLOBAL_STRING
|
507 |
|
|
|
508 |
|
|
const string regex_str(regex_c_str);
|
509 |
|
|
EXPECT_DEATH(GlobalFunction(), regex_str);
|
510 |
|
|
|
511 |
|
|
# endif // GTEST_HAS_GLOBAL_STRING
|
512 |
|
|
|
513 |
|
|
# if !GTEST_USES_PCRE
|
514 |
|
|
|
515 |
|
|
const ::std::string regex_std_str(regex_c_str);
|
516 |
|
|
EXPECT_DEATH(GlobalFunction(), regex_std_str);
|
517 |
|
|
|
518 |
|
|
# endif // !GTEST_USES_PCRE
|
519 |
|
|
}
|
520 |
|
|
|
521 |
|
|
// Tests that a non-void function can be used in a death test.
|
522 |
|
|
TEST_F(TestForDeathTest, NonVoidFunction) {
|
523 |
|
|
ASSERT_DEATH(NonVoidFunction(), "NonVoidFunction");
|
524 |
|
|
}
|
525 |
|
|
|
526 |
|
|
// Tests that functions that take parameter(s) can be used in a death test.
|
527 |
|
|
TEST_F(TestForDeathTest, FunctionWithParameter) {
|
528 |
|
|
EXPECT_DEATH(DieIf(true), "DieIf\\(\\)");
|
529 |
|
|
EXPECT_DEATH(DieIfLessThan(2, 3), "DieIfLessThan");
|
530 |
|
|
}
|
531 |
|
|
|
532 |
|
|
// Tests that ASSERT_DEATH can be used outside a TEST, TEST_F, or test fixture.
|
533 |
|
|
TEST_F(TestForDeathTest, OutsideFixture) {
|
534 |
|
|
DeathTestSubroutine();
|
535 |
|
|
}
|
536 |
|
|
|
537 |
|
|
// Tests that death tests can be done inside a loop.
|
538 |
|
|
TEST_F(TestForDeathTest, InsideLoop) {
|
539 |
|
|
for (int i = 0; i < 5; i++) {
|
540 |
|
|
EXPECT_DEATH(DieIfLessThan(-1, i), "DieIfLessThan") << "where i == " << i;
|
541 |
|
|
}
|
542 |
|
|
}
|
543 |
|
|
|
544 |
|
|
// Tests that a compound statement can be used in a death test.
|
545 |
|
|
TEST_F(TestForDeathTest, CompoundStatement) {
|
546 |
|
|
EXPECT_DEATH({ // NOLINT
|
547 |
|
|
const int x = 2;
|
548 |
|
|
const int y = x + 1;
|
549 |
|
|
DieIfLessThan(x, y);
|
550 |
|
|
},
|
551 |
|
|
"DieIfLessThan");
|
552 |
|
|
}
|
553 |
|
|
|
554 |
|
|
// Tests that code that doesn't die causes a death test to fail.
|
555 |
|
|
TEST_F(TestForDeathTest, DoesNotDie) {
|
556 |
|
|
EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(DieIf(false), "DieIf"),
|
557 |
|
|
"failed to die");
|
558 |
|
|
}
|
559 |
|
|
|
560 |
|
|
// Tests that a death test fails when the error message isn't expected.
|
561 |
|
|
TEST_F(TestForDeathTest, ErrorMessageMismatch) {
|
562 |
|
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
563 |
|
|
EXPECT_DEATH(DieIf(true), "DieIfLessThan") << "End of death test message.";
|
564 |
|
|
}, "died but not with expected error");
|
565 |
|
|
}
|
566 |
|
|
|
567 |
|
|
// On exit, *aborted will be true iff the EXPECT_DEATH() statement
|
568 |
|
|
// aborted the function.
|
569 |
|
|
void ExpectDeathTestHelper(bool* aborted) {
|
570 |
|
|
*aborted = true;
|
571 |
|
|
EXPECT_DEATH(DieIf(false), "DieIf"); // This assertion should fail.
|
572 |
|
|
*aborted = false;
|
573 |
|
|
}
|
574 |
|
|
|
575 |
|
|
// Tests that EXPECT_DEATH doesn't abort the test on failure.
|
576 |
|
|
TEST_F(TestForDeathTest, EXPECT_DEATH) {
|
577 |
|
|
bool aborted = true;
|
578 |
|
|
EXPECT_NONFATAL_FAILURE(ExpectDeathTestHelper(&aborted),
|
579 |
|
|
"failed to die");
|
580 |
|
|
EXPECT_FALSE(aborted);
|
581 |
|
|
}
|
582 |
|
|
|
583 |
|
|
// Tests that ASSERT_DEATH does abort the test on failure.
|
584 |
|
|
TEST_F(TestForDeathTest, ASSERT_DEATH) {
|
585 |
|
|
static bool aborted;
|
586 |
|
|
EXPECT_FATAL_FAILURE({ // NOLINT
|
587 |
|
|
aborted = true;
|
588 |
|
|
ASSERT_DEATH(DieIf(false), "DieIf"); // This assertion should fail.
|
589 |
|
|
aborted = false;
|
590 |
|
|
}, "failed to die");
|
591 |
|
|
EXPECT_TRUE(aborted);
|
592 |
|
|
}
|
593 |
|
|
|
594 |
|
|
// Tests that EXPECT_DEATH evaluates the arguments exactly once.
|
595 |
|
|
TEST_F(TestForDeathTest, SingleEvaluation) {
|
596 |
|
|
int x = 3;
|
597 |
|
|
EXPECT_DEATH(DieIf((++x) == 4), "DieIf");
|
598 |
|
|
|
599 |
|
|
const char* regex = "DieIf";
|
600 |
|
|
const char* regex_save = regex;
|
601 |
|
|
EXPECT_DEATH(DieIfLessThan(3, 4), regex++);
|
602 |
|
|
EXPECT_EQ(regex_save + 1, regex);
|
603 |
|
|
}
|
604 |
|
|
|
605 |
|
|
// Tests that run-away death tests are reported as failures.
|
606 |
|
|
TEST_F(TestForDeathTest, RunawayIsFailure) {
|
607 |
|
|
EXPECT_NONFATAL_FAILURE(EXPECT_DEATH(static_cast<void>(0), "Foo"),
|
608 |
|
|
"failed to die.");
|
609 |
|
|
}
|
610 |
|
|
|
611 |
|
|
// Tests that death tests report executing 'return' in the statement as
|
612 |
|
|
// failure.
|
613 |
|
|
TEST_F(TestForDeathTest, ReturnIsFailure) {
|
614 |
|
|
EXPECT_FATAL_FAILURE(ASSERT_DEATH(return, "Bar"),
|
615 |
|
|
"illegal return in test statement.");
|
616 |
|
|
}
|
617 |
|
|
|
618 |
|
|
// Tests that EXPECT_DEBUG_DEATH works as expected, that is, you can stream a
|
619 |
|
|
// message to it, and in debug mode it:
|
620 |
|
|
// 1. Asserts on death.
|
621 |
|
|
// 2. Has no side effect.
|
622 |
|
|
//
|
623 |
|
|
// And in opt mode, it:
|
624 |
|
|
// 1. Has side effects but does not assert.
|
625 |
|
|
TEST_F(TestForDeathTest, TestExpectDebugDeath) {
|
626 |
|
|
int sideeffect = 0;
|
627 |
|
|
|
628 |
|
|
EXPECT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
|
629 |
|
|
<< "Must accept a streamed message";
|
630 |
|
|
|
631 |
|
|
# ifdef NDEBUG
|
632 |
|
|
|
633 |
|
|
// Checks that the assignment occurs in opt mode (sideeffect).
|
634 |
|
|
EXPECT_EQ(12, sideeffect);
|
635 |
|
|
|
636 |
|
|
# else
|
637 |
|
|
|
638 |
|
|
// Checks that the assignment does not occur in dbg mode (no sideeffect).
|
639 |
|
|
EXPECT_EQ(0, sideeffect);
|
640 |
|
|
|
641 |
|
|
# endif
|
642 |
|
|
}
|
643 |
|
|
|
644 |
|
|
// Tests that ASSERT_DEBUG_DEATH works as expected, that is, you can stream a
|
645 |
|
|
// message to it, and in debug mode it:
|
646 |
|
|
// 1. Asserts on death.
|
647 |
|
|
// 2. Has no side effect.
|
648 |
|
|
//
|
649 |
|
|
// And in opt mode, it:
|
650 |
|
|
// 1. Has side effects but does not assert.
|
651 |
|
|
TEST_F(TestForDeathTest, TestAssertDebugDeath) {
|
652 |
|
|
int sideeffect = 0;
|
653 |
|
|
|
654 |
|
|
ASSERT_DEBUG_DEATH(DieInDebugElse12(&sideeffect), "death.*DieInDebugElse12")
|
655 |
|
|
<< "Must accept a streamed message";
|
656 |
|
|
|
657 |
|
|
# ifdef NDEBUG
|
658 |
|
|
|
659 |
|
|
// Checks that the assignment occurs in opt mode (sideeffect).
|
660 |
|
|
EXPECT_EQ(12, sideeffect);
|
661 |
|
|
|
662 |
|
|
# else
|
663 |
|
|
|
664 |
|
|
// Checks that the assignment does not occur in dbg mode (no sideeffect).
|
665 |
|
|
EXPECT_EQ(0, sideeffect);
|
666 |
|
|
|
667 |
|
|
# endif
|
668 |
|
|
}
|
669 |
|
|
|
670 |
|
|
# ifndef NDEBUG
|
671 |
|
|
|
672 |
|
|
void ExpectDebugDeathHelper(bool* aborted) {
|
673 |
|
|
*aborted = true;
|
674 |
|
|
EXPECT_DEBUG_DEATH(return, "") << "This is expected to fail.";
|
675 |
|
|
*aborted = false;
|
676 |
|
|
}
|
677 |
|
|
|
678 |
|
|
# if GTEST_OS_WINDOWS
|
679 |
|
|
TEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) {
|
680 |
|
|
printf("This test should be considered failing if it shows "
|
681 |
|
|
"any pop-up dialogs.\n");
|
682 |
|
|
fflush(stdout);
|
683 |
|
|
|
684 |
|
|
EXPECT_DEATH({
|
685 |
|
|
testing::GTEST_FLAG(catch_exceptions) = false;
|
686 |
|
|
abort();
|
687 |
|
|
}, "");
|
688 |
|
|
}
|
689 |
|
|
# endif // GTEST_OS_WINDOWS
|
690 |
|
|
|
691 |
|
|
// Tests that EXPECT_DEBUG_DEATH in debug mode does not abort
|
692 |
|
|
// the function.
|
693 |
|
|
TEST_F(TestForDeathTest, ExpectDebugDeathDoesNotAbort) {
|
694 |
|
|
bool aborted = true;
|
695 |
|
|
EXPECT_NONFATAL_FAILURE(ExpectDebugDeathHelper(&aborted), "");
|
696 |
|
|
EXPECT_FALSE(aborted);
|
697 |
|
|
}
|
698 |
|
|
|
699 |
|
|
void AssertDebugDeathHelper(bool* aborted) {
|
700 |
|
|
*aborted = true;
|
701 |
|
|
GTEST_LOG_(INFO) << "Before ASSERT_DEBUG_DEATH";
|
702 |
|
|
ASSERT_DEBUG_DEATH(GTEST_LOG_(INFO) << "In ASSERT_DEBUG_DEATH"; return, "")
|
703 |
|
|
<< "This is expected to fail.";
|
704 |
|
|
GTEST_LOG_(INFO) << "After ASSERT_DEBUG_DEATH";
|
705 |
|
|
*aborted = false;
|
706 |
|
|
}
|
707 |
|
|
|
708 |
|
|
// Tests that ASSERT_DEBUG_DEATH in debug mode aborts the function on
|
709 |
|
|
// failure.
|
710 |
|
|
TEST_F(TestForDeathTest, AssertDebugDeathAborts) {
|
711 |
|
|
static bool aborted;
|
712 |
|
|
aborted = false;
|
713 |
|
|
EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
|
714 |
|
|
EXPECT_TRUE(aborted);
|
715 |
|
|
}
|
716 |
|
|
|
717 |
|
|
TEST_F(TestForDeathTest, AssertDebugDeathAborts2) {
|
718 |
|
|
static bool aborted;
|
719 |
|
|
aborted = false;
|
720 |
|
|
EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
|
721 |
|
|
EXPECT_TRUE(aborted);
|
722 |
|
|
}
|
723 |
|
|
|
724 |
|
|
TEST_F(TestForDeathTest, AssertDebugDeathAborts3) {
|
725 |
|
|
static bool aborted;
|
726 |
|
|
aborted = false;
|
727 |
|
|
EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
|
728 |
|
|
EXPECT_TRUE(aborted);
|
729 |
|
|
}
|
730 |
|
|
|
731 |
|
|
TEST_F(TestForDeathTest, AssertDebugDeathAborts4) {
|
732 |
|
|
static bool aborted;
|
733 |
|
|
aborted = false;
|
734 |
|
|
EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
|
735 |
|
|
EXPECT_TRUE(aborted);
|
736 |
|
|
}
|
737 |
|
|
|
738 |
|
|
TEST_F(TestForDeathTest, AssertDebugDeathAborts5) {
|
739 |
|
|
static bool aborted;
|
740 |
|
|
aborted = false;
|
741 |
|
|
EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
|
742 |
|
|
EXPECT_TRUE(aborted);
|
743 |
|
|
}
|
744 |
|
|
|
745 |
|
|
TEST_F(TestForDeathTest, AssertDebugDeathAborts6) {
|
746 |
|
|
static bool aborted;
|
747 |
|
|
aborted = false;
|
748 |
|
|
EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
|
749 |
|
|
EXPECT_TRUE(aborted);
|
750 |
|
|
}
|
751 |
|
|
|
752 |
|
|
TEST_F(TestForDeathTest, AssertDebugDeathAborts7) {
|
753 |
|
|
static bool aborted;
|
754 |
|
|
aborted = false;
|
755 |
|
|
EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
|
756 |
|
|
EXPECT_TRUE(aborted);
|
757 |
|
|
}
|
758 |
|
|
|
759 |
|
|
TEST_F(TestForDeathTest, AssertDebugDeathAborts8) {
|
760 |
|
|
static bool aborted;
|
761 |
|
|
aborted = false;
|
762 |
|
|
EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
|
763 |
|
|
EXPECT_TRUE(aborted);
|
764 |
|
|
}
|
765 |
|
|
|
766 |
|
|
TEST_F(TestForDeathTest, AssertDebugDeathAborts9) {
|
767 |
|
|
static bool aborted;
|
768 |
|
|
aborted = false;
|
769 |
|
|
EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
|
770 |
|
|
EXPECT_TRUE(aborted);
|
771 |
|
|
}
|
772 |
|
|
|
773 |
|
|
TEST_F(TestForDeathTest, AssertDebugDeathAborts10) {
|
774 |
|
|
static bool aborted;
|
775 |
|
|
aborted = false;
|
776 |
|
|
EXPECT_FATAL_FAILURE(AssertDebugDeathHelper(&aborted), "");
|
777 |
|
|
EXPECT_TRUE(aborted);
|
778 |
|
|
}
|
779 |
|
|
|
780 |
|
|
# endif // _NDEBUG
|
781 |
|
|
|
782 |
|
|
// Tests the *_EXIT family of macros, using a variety of predicates.
|
783 |
|
|
static void TestExitMacros() {
|
784 |
|
|
EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
|
785 |
|
|
ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), "");
|
786 |
|
|
|
787 |
|
|
# if GTEST_OS_WINDOWS
|
788 |
|
|
|
789 |
|
|
// Of all signals effects on the process exit code, only those of SIGABRT
|
790 |
|
|
// are documented on Windows.
|
791 |
|
|
// See http://msdn.microsoft.com/en-us/library/dwwzkt4c(VS.71).aspx.
|
792 |
|
|
EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar";
|
793 |
|
|
|
794 |
|
|
# else
|
795 |
|
|
|
796 |
|
|
EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo";
|
797 |
|
|
ASSERT_EXIT(raise(SIGUSR2), testing::KilledBySignal(SIGUSR2), "") << "bar";
|
798 |
|
|
|
799 |
|
|
EXPECT_FATAL_FAILURE({ // NOLINT
|
800 |
|
|
ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "")
|
801 |
|
|
<< "This failure is expected, too.";
|
802 |
|
|
}, "This failure is expected, too.");
|
803 |
|
|
|
804 |
|
|
# endif // GTEST_OS_WINDOWS
|
805 |
|
|
|
806 |
|
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
807 |
|
|
EXPECT_EXIT(raise(SIGSEGV), testing::ExitedWithCode(0), "")
|
808 |
|
|
<< "This failure is expected.";
|
809 |
|
|
}, "This failure is expected.");
|
810 |
|
|
}
|
811 |
|
|
|
812 |
|
|
TEST_F(TestForDeathTest, ExitMacros) {
|
813 |
|
|
TestExitMacros();
|
814 |
|
|
}
|
815 |
|
|
|
816 |
|
|
TEST_F(TestForDeathTest, ExitMacrosUsingFork) {
|
817 |
|
|
testing::GTEST_FLAG(death_test_use_fork) = true;
|
818 |
|
|
TestExitMacros();
|
819 |
|
|
}
|
820 |
|
|
|
821 |
|
|
TEST_F(TestForDeathTest, InvalidStyle) {
|
822 |
|
|
testing::GTEST_FLAG(death_test_style) = "rococo";
|
823 |
|
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
824 |
|
|
EXPECT_DEATH(_exit(0), "") << "This failure is expected.";
|
825 |
|
|
}, "This failure is expected.");
|
826 |
|
|
}
|
827 |
|
|
|
828 |
|
|
TEST_F(TestForDeathTest, DeathTestFailedOutput) {
|
829 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
830 |
|
|
EXPECT_NONFATAL_FAILURE(
|
831 |
|
|
EXPECT_DEATH(DieWithMessage("death\n"),
|
832 |
|
|
"expected message"),
|
833 |
|
|
"Actual msg:\n"
|
834 |
|
|
"[ DEATH ] death\n");
|
835 |
|
|
}
|
836 |
|
|
|
837 |
|
|
TEST_F(TestForDeathTest, DeathTestUnexpectedReturnOutput) {
|
838 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
839 |
|
|
EXPECT_NONFATAL_FAILURE(
|
840 |
|
|
EXPECT_DEATH({
|
841 |
|
|
fprintf(stderr, "returning\n");
|
842 |
|
|
fflush(stderr);
|
843 |
|
|
return;
|
844 |
|
|
}, ""),
|
845 |
|
|
" Result: illegal return in test statement.\n"
|
846 |
|
|
" Error msg:\n"
|
847 |
|
|
"[ DEATH ] returning\n");
|
848 |
|
|
}
|
849 |
|
|
|
850 |
|
|
TEST_F(TestForDeathTest, DeathTestBadExitCodeOutput) {
|
851 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
852 |
|
|
EXPECT_NONFATAL_FAILURE(
|
853 |
|
|
EXPECT_EXIT(DieWithMessage("exiting with rc 1\n"),
|
854 |
|
|
testing::ExitedWithCode(3),
|
855 |
|
|
"expected message"),
|
856 |
|
|
" Result: died but not with expected exit code:\n"
|
857 |
|
|
" Exited with exit status 1\n"
|
858 |
|
|
"Actual msg:\n"
|
859 |
|
|
"[ DEATH ] exiting with rc 1\n");
|
860 |
|
|
}
|
861 |
|
|
|
862 |
|
|
TEST_F(TestForDeathTest, DeathTestMultiLineMatchFail) {
|
863 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
864 |
|
|
EXPECT_NONFATAL_FAILURE(
|
865 |
|
|
EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"),
|
866 |
|
|
"line 1\nxyz\nline 3\n"),
|
867 |
|
|
"Actual msg:\n"
|
868 |
|
|
"[ DEATH ] line 1\n"
|
869 |
|
|
"[ DEATH ] line 2\n"
|
870 |
|
|
"[ DEATH ] line 3\n");
|
871 |
|
|
}
|
872 |
|
|
|
873 |
|
|
TEST_F(TestForDeathTest, DeathTestMultiLineMatchPass) {
|
874 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
875 |
|
|
EXPECT_DEATH(DieWithMessage("line 1\nline 2\nline 3\n"),
|
876 |
|
|
"line 1\nline 2\nline 3\n");
|
877 |
|
|
}
|
878 |
|
|
|
879 |
|
|
// A DeathTestFactory that returns MockDeathTests.
|
880 |
|
|
class MockDeathTestFactory : public DeathTestFactory {
|
881 |
|
|
public:
|
882 |
|
|
MockDeathTestFactory();
|
883 |
|
|
virtual bool Create(const char* statement,
|
884 |
|
|
const ::testing::internal::RE* regex,
|
885 |
|
|
const char* file, int line, DeathTest** test);
|
886 |
|
|
|
887 |
|
|
// Sets the parameters for subsequent calls to Create.
|
888 |
|
|
void SetParameters(bool create, DeathTest::TestRole role,
|
889 |
|
|
int status, bool passed);
|
890 |
|
|
|
891 |
|
|
// Accessors.
|
892 |
|
|
int AssumeRoleCalls() const { return assume_role_calls_; }
|
893 |
|
|
int WaitCalls() const { return wait_calls_; }
|
894 |
|
|
size_t PassedCalls() const { return passed_args_.size(); }
|
895 |
|
|
bool PassedArgument(int n) const { return passed_args_[n]; }
|
896 |
|
|
size_t AbortCalls() const { return abort_args_.size(); }
|
897 |
|
|
DeathTest::AbortReason AbortArgument(int n) const {
|
898 |
|
|
return abort_args_[n];
|
899 |
|
|
}
|
900 |
|
|
bool TestDeleted() const { return test_deleted_; }
|
901 |
|
|
|
902 |
|
|
private:
|
903 |
|
|
friend class MockDeathTest;
|
904 |
|
|
// If true, Create will return a MockDeathTest; otherwise it returns
|
905 |
|
|
// NULL.
|
906 |
|
|
bool create_;
|
907 |
|
|
// The value a MockDeathTest will return from its AssumeRole method.
|
908 |
|
|
DeathTest::TestRole role_;
|
909 |
|
|
// The value a MockDeathTest will return from its Wait method.
|
910 |
|
|
int status_;
|
911 |
|
|
// The value a MockDeathTest will return from its Passed method.
|
912 |
|
|
bool passed_;
|
913 |
|
|
|
914 |
|
|
// Number of times AssumeRole was called.
|
915 |
|
|
int assume_role_calls_;
|
916 |
|
|
// Number of times Wait was called.
|
917 |
|
|
int wait_calls_;
|
918 |
|
|
// The arguments to the calls to Passed since the last call to
|
919 |
|
|
// SetParameters.
|
920 |
|
|
std::vector<bool> passed_args_;
|
921 |
|
|
// The arguments to the calls to Abort since the last call to
|
922 |
|
|
// SetParameters.
|
923 |
|
|
std::vector<DeathTest::AbortReason> abort_args_;
|
924 |
|
|
// True if the last MockDeathTest returned by Create has been
|
925 |
|
|
// deleted.
|
926 |
|
|
bool test_deleted_;
|
927 |
|
|
};
|
928 |
|
|
|
929 |
|
|
|
930 |
|
|
// A DeathTest implementation useful in testing. It returns values set
|
931 |
|
|
// at its creation from its various inherited DeathTest methods, and
|
932 |
|
|
// reports calls to those methods to its parent MockDeathTestFactory
|
933 |
|
|
// object.
|
934 |
|
|
class MockDeathTest : public DeathTest {
|
935 |
|
|
public:
|
936 |
|
|
MockDeathTest(MockDeathTestFactory *parent,
|
937 |
|
|
TestRole role, int status, bool passed) :
|
938 |
|
|
parent_(parent), role_(role), status_(status), passed_(passed) {
|
939 |
|
|
}
|
940 |
|
|
virtual ~MockDeathTest() {
|
941 |
|
|
parent_->test_deleted_ = true;
|
942 |
|
|
}
|
943 |
|
|
virtual TestRole AssumeRole() {
|
944 |
|
|
++parent_->assume_role_calls_;
|
945 |
|
|
return role_;
|
946 |
|
|
}
|
947 |
|
|
virtual int Wait() {
|
948 |
|
|
++parent_->wait_calls_;
|
949 |
|
|
return status_;
|
950 |
|
|
}
|
951 |
|
|
virtual bool Passed(bool exit_status_ok) {
|
952 |
|
|
parent_->passed_args_.push_back(exit_status_ok);
|
953 |
|
|
return passed_;
|
954 |
|
|
}
|
955 |
|
|
virtual void Abort(AbortReason reason) {
|
956 |
|
|
parent_->abort_args_.push_back(reason);
|
957 |
|
|
}
|
958 |
|
|
|
959 |
|
|
private:
|
960 |
|
|
MockDeathTestFactory* const parent_;
|
961 |
|
|
const TestRole role_;
|
962 |
|
|
const int status_;
|
963 |
|
|
const bool passed_;
|
964 |
|
|
};
|
965 |
|
|
|
966 |
|
|
|
967 |
|
|
// MockDeathTestFactory constructor.
|
968 |
|
|
MockDeathTestFactory::MockDeathTestFactory()
|
969 |
|
|
: create_(true),
|
970 |
|
|
role_(DeathTest::OVERSEE_TEST),
|
971 |
|
|
status_(0),
|
972 |
|
|
passed_(true),
|
973 |
|
|
assume_role_calls_(0),
|
974 |
|
|
wait_calls_(0),
|
975 |
|
|
passed_args_(),
|
976 |
|
|
abort_args_() {
|
977 |
|
|
}
|
978 |
|
|
|
979 |
|
|
|
980 |
|
|
// Sets the parameters for subsequent calls to Create.
|
981 |
|
|
void MockDeathTestFactory::SetParameters(bool create,
|
982 |
|
|
DeathTest::TestRole role,
|
983 |
|
|
int status, bool passed) {
|
984 |
|
|
create_ = create;
|
985 |
|
|
role_ = role;
|
986 |
|
|
status_ = status;
|
987 |
|
|
passed_ = passed;
|
988 |
|
|
|
989 |
|
|
assume_role_calls_ = 0;
|
990 |
|
|
wait_calls_ = 0;
|
991 |
|
|
passed_args_.clear();
|
992 |
|
|
abort_args_.clear();
|
993 |
|
|
}
|
994 |
|
|
|
995 |
|
|
|
996 |
|
|
// Sets test to NULL (if create_ is false) or to the address of a new
|
997 |
|
|
// MockDeathTest object with parameters taken from the last call
|
998 |
|
|
// to SetParameters (if create_ is true). Always returns true.
|
999 |
|
|
bool MockDeathTestFactory::Create(const char* /*statement*/,
|
1000 |
|
|
const ::testing::internal::RE* /*regex*/,
|
1001 |
|
|
const char* /*file*/,
|
1002 |
|
|
int /*line*/,
|
1003 |
|
|
DeathTest** test) {
|
1004 |
|
|
test_deleted_ = false;
|
1005 |
|
|
if (create_) {
|
1006 |
|
|
*test = new MockDeathTest(this, role_, status_, passed_);
|
1007 |
|
|
} else {
|
1008 |
|
|
*test = NULL;
|
1009 |
|
|
}
|
1010 |
|
|
return true;
|
1011 |
|
|
}
|
1012 |
|
|
|
1013 |
|
|
// A test fixture for testing the logic of the GTEST_DEATH_TEST_ macro.
|
1014 |
|
|
// It installs a MockDeathTestFactory that is used for the duration
|
1015 |
|
|
// of the test case.
|
1016 |
|
|
class MacroLogicDeathTest : public testing::Test {
|
1017 |
|
|
protected:
|
1018 |
|
|
static testing::internal::ReplaceDeathTestFactory* replacer_;
|
1019 |
|
|
static MockDeathTestFactory* factory_;
|
1020 |
|
|
|
1021 |
|
|
static void SetUpTestCase() {
|
1022 |
|
|
factory_ = new MockDeathTestFactory;
|
1023 |
|
|
replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_);
|
1024 |
|
|
}
|
1025 |
|
|
|
1026 |
|
|
static void TearDownTestCase() {
|
1027 |
|
|
delete replacer_;
|
1028 |
|
|
replacer_ = NULL;
|
1029 |
|
|
delete factory_;
|
1030 |
|
|
factory_ = NULL;
|
1031 |
|
|
}
|
1032 |
|
|
|
1033 |
|
|
// Runs a death test that breaks the rules by returning. Such a death
|
1034 |
|
|
// test cannot be run directly from a test routine that uses a
|
1035 |
|
|
// MockDeathTest, or the remainder of the routine will not be executed.
|
1036 |
|
|
static void RunReturningDeathTest(bool* flag) {
|
1037 |
|
|
ASSERT_DEATH({ // NOLINT
|
1038 |
|
|
*flag = true;
|
1039 |
|
|
return;
|
1040 |
|
|
}, "");
|
1041 |
|
|
}
|
1042 |
|
|
};
|
1043 |
|
|
|
1044 |
|
|
testing::internal::ReplaceDeathTestFactory* MacroLogicDeathTest::replacer_
|
1045 |
|
|
= NULL;
|
1046 |
|
|
MockDeathTestFactory* MacroLogicDeathTest::factory_ = NULL;
|
1047 |
|
|
|
1048 |
|
|
|
1049 |
|
|
// Test that nothing happens when the factory doesn't return a DeathTest:
|
1050 |
|
|
TEST_F(MacroLogicDeathTest, NothingHappens) {
|
1051 |
|
|
bool flag = false;
|
1052 |
|
|
factory_->SetParameters(false, DeathTest::OVERSEE_TEST, 0, true);
|
1053 |
|
|
EXPECT_DEATH(flag = true, "");
|
1054 |
|
|
EXPECT_FALSE(flag);
|
1055 |
|
|
EXPECT_EQ(0, factory_->AssumeRoleCalls());
|
1056 |
|
|
EXPECT_EQ(0, factory_->WaitCalls());
|
1057 |
|
|
EXPECT_EQ(0U, factory_->PassedCalls());
|
1058 |
|
|
EXPECT_EQ(0U, factory_->AbortCalls());
|
1059 |
|
|
EXPECT_FALSE(factory_->TestDeleted());
|
1060 |
|
|
}
|
1061 |
|
|
|
1062 |
|
|
// Test that the parent process doesn't run the death test code,
|
1063 |
|
|
// and that the Passed method returns false when the (simulated)
|
1064 |
|
|
// child process exits with status 0:
|
1065 |
|
|
TEST_F(MacroLogicDeathTest, ChildExitsSuccessfully) {
|
1066 |
|
|
bool flag = false;
|
1067 |
|
|
factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 0, true);
|
1068 |
|
|
EXPECT_DEATH(flag = true, "");
|
1069 |
|
|
EXPECT_FALSE(flag);
|
1070 |
|
|
EXPECT_EQ(1, factory_->AssumeRoleCalls());
|
1071 |
|
|
EXPECT_EQ(1, factory_->WaitCalls());
|
1072 |
|
|
ASSERT_EQ(1U, factory_->PassedCalls());
|
1073 |
|
|
EXPECT_FALSE(factory_->PassedArgument(0));
|
1074 |
|
|
EXPECT_EQ(0U, factory_->AbortCalls());
|
1075 |
|
|
EXPECT_TRUE(factory_->TestDeleted());
|
1076 |
|
|
}
|
1077 |
|
|
|
1078 |
|
|
// Tests that the Passed method was given the argument "true" when
|
1079 |
|
|
// the (simulated) child process exits with status 1:
|
1080 |
|
|
TEST_F(MacroLogicDeathTest, ChildExitsUnsuccessfully) {
|
1081 |
|
|
bool flag = false;
|
1082 |
|
|
factory_->SetParameters(true, DeathTest::OVERSEE_TEST, 1, true);
|
1083 |
|
|
EXPECT_DEATH(flag = true, "");
|
1084 |
|
|
EXPECT_FALSE(flag);
|
1085 |
|
|
EXPECT_EQ(1, factory_->AssumeRoleCalls());
|
1086 |
|
|
EXPECT_EQ(1, factory_->WaitCalls());
|
1087 |
|
|
ASSERT_EQ(1U, factory_->PassedCalls());
|
1088 |
|
|
EXPECT_TRUE(factory_->PassedArgument(0));
|
1089 |
|
|
EXPECT_EQ(0U, factory_->AbortCalls());
|
1090 |
|
|
EXPECT_TRUE(factory_->TestDeleted());
|
1091 |
|
|
}
|
1092 |
|
|
|
1093 |
|
|
// Tests that the (simulated) child process executes the death test
|
1094 |
|
|
// code, and is aborted with the correct AbortReason if it
|
1095 |
|
|
// executes a return statement.
|
1096 |
|
|
TEST_F(MacroLogicDeathTest, ChildPerformsReturn) {
|
1097 |
|
|
bool flag = false;
|
1098 |
|
|
factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);
|
1099 |
|
|
RunReturningDeathTest(&flag);
|
1100 |
|
|
EXPECT_TRUE(flag);
|
1101 |
|
|
EXPECT_EQ(1, factory_->AssumeRoleCalls());
|
1102 |
|
|
EXPECT_EQ(0, factory_->WaitCalls());
|
1103 |
|
|
EXPECT_EQ(0U, factory_->PassedCalls());
|
1104 |
|
|
EXPECT_EQ(1U, factory_->AbortCalls());
|
1105 |
|
|
EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
|
1106 |
|
|
factory_->AbortArgument(0));
|
1107 |
|
|
EXPECT_TRUE(factory_->TestDeleted());
|
1108 |
|
|
}
|
1109 |
|
|
|
1110 |
|
|
// Tests that the (simulated) child process is aborted with the
|
1111 |
|
|
// correct AbortReason if it does not die.
|
1112 |
|
|
TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {
|
1113 |
|
|
bool flag = false;
|
1114 |
|
|
factory_->SetParameters(true, DeathTest::EXECUTE_TEST, 0, true);
|
1115 |
|
|
EXPECT_DEATH(flag = true, "");
|
1116 |
|
|
EXPECT_TRUE(flag);
|
1117 |
|
|
EXPECT_EQ(1, factory_->AssumeRoleCalls());
|
1118 |
|
|
EXPECT_EQ(0, factory_->WaitCalls());
|
1119 |
|
|
EXPECT_EQ(0U, factory_->PassedCalls());
|
1120 |
|
|
// This time there are two calls to Abort: one since the test didn't
|
1121 |
|
|
// die, and another from the ReturnSentinel when it's destroyed. The
|
1122 |
|
|
// sentinel normally isn't destroyed if a test doesn't die, since
|
1123 |
|
|
// _exit(2) is called in that case by ForkingDeathTest, but not by
|
1124 |
|
|
// our MockDeathTest.
|
1125 |
|
|
ASSERT_EQ(2U, factory_->AbortCalls());
|
1126 |
|
|
EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE,
|
1127 |
|
|
factory_->AbortArgument(0));
|
1128 |
|
|
EXPECT_EQ(DeathTest::TEST_ENCOUNTERED_RETURN_STATEMENT,
|
1129 |
|
|
factory_->AbortArgument(1));
|
1130 |
|
|
EXPECT_TRUE(factory_->TestDeleted());
|
1131 |
|
|
}
|
1132 |
|
|
|
1133 |
|
|
// Tests that a successful death test does not register a successful
|
1134 |
|
|
// test part.
|
1135 |
|
|
TEST(SuccessRegistrationDeathTest, NoSuccessPart) {
|
1136 |
|
|
EXPECT_DEATH(_exit(1), "");
|
1137 |
|
|
EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
|
1138 |
|
|
}
|
1139 |
|
|
|
1140 |
|
|
TEST(StreamingAssertionsDeathTest, DeathTest) {
|
1141 |
|
|
EXPECT_DEATH(_exit(1), "") << "unexpected failure";
|
1142 |
|
|
ASSERT_DEATH(_exit(1), "") << "unexpected failure";
|
1143 |
|
|
EXPECT_NONFATAL_FAILURE({ // NOLINT
|
1144 |
|
|
EXPECT_DEATH(_exit(0), "") << "expected failure";
|
1145 |
|
|
}, "expected failure");
|
1146 |
|
|
EXPECT_FATAL_FAILURE({ // NOLINT
|
1147 |
|
|
ASSERT_DEATH(_exit(0), "") << "expected failure";
|
1148 |
|
|
}, "expected failure");
|
1149 |
|
|
}
|
1150 |
|
|
|
1151 |
|
|
// Tests that GetLastErrnoDescription returns an empty string when the
|
1152 |
|
|
// last error is 0 and non-empty string when it is non-zero.
|
1153 |
|
|
TEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) {
|
1154 |
|
|
errno = ENOENT;
|
1155 |
|
|
EXPECT_STRNE("", GetLastErrnoDescription().c_str());
|
1156 |
|
|
errno = 0;
|
1157 |
|
|
EXPECT_STREQ("", GetLastErrnoDescription().c_str());
|
1158 |
|
|
}
|
1159 |
|
|
|
1160 |
|
|
# if GTEST_OS_WINDOWS
|
1161 |
|
|
TEST(AutoHandleTest, AutoHandleWorks) {
|
1162 |
|
|
HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
|
1163 |
|
|
ASSERT_NE(INVALID_HANDLE_VALUE, handle);
|
1164 |
|
|
|
1165 |
|
|
// Tests that the AutoHandle is correctly initialized with a handle.
|
1166 |
|
|
testing::internal::AutoHandle auto_handle(handle);
|
1167 |
|
|
EXPECT_EQ(handle, auto_handle.Get());
|
1168 |
|
|
|
1169 |
|
|
// Tests that Reset assigns INVALID_HANDLE_VALUE.
|
1170 |
|
|
// Note that this cannot verify whether the original handle is closed.
|
1171 |
|
|
auto_handle.Reset();
|
1172 |
|
|
EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle.Get());
|
1173 |
|
|
|
1174 |
|
|
// Tests that Reset assigns the new handle.
|
1175 |
|
|
// Note that this cannot verify whether the original handle is closed.
|
1176 |
|
|
handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
|
1177 |
|
|
ASSERT_NE(INVALID_HANDLE_VALUE, handle);
|
1178 |
|
|
auto_handle.Reset(handle);
|
1179 |
|
|
EXPECT_EQ(handle, auto_handle.Get());
|
1180 |
|
|
|
1181 |
|
|
// Tests that AutoHandle contains INVALID_HANDLE_VALUE by default.
|
1182 |
|
|
testing::internal::AutoHandle auto_handle2;
|
1183 |
|
|
EXPECT_EQ(INVALID_HANDLE_VALUE, auto_handle2.Get());
|
1184 |
|
|
}
|
1185 |
|
|
# endif // GTEST_OS_WINDOWS
|
1186 |
|
|
|
1187 |
|
|
# if GTEST_OS_WINDOWS
|
1188 |
|
|
typedef unsigned __int64 BiggestParsable;
|
1189 |
|
|
typedef signed __int64 BiggestSignedParsable;
|
1190 |
|
|
# else
|
1191 |
|
|
typedef unsigned long long BiggestParsable;
|
1192 |
|
|
typedef signed long long BiggestSignedParsable;
|
1193 |
|
|
# endif // GTEST_OS_WINDOWS
|
1194 |
|
|
|
1195 |
|
|
// We cannot use std::numeric_limits<T>::max() as it clashes with the
|
1196 |
|
|
// max() macro defined by <windows.h>.
|
1197 |
|
|
const BiggestParsable kBiggestParsableMax = ULLONG_MAX;
|
1198 |
|
|
const BiggestSignedParsable kBiggestSignedParsableMax = LLONG_MAX;
|
1199 |
|
|
|
1200 |
|
|
TEST(ParseNaturalNumberTest, RejectsInvalidFormat) {
|
1201 |
|
|
BiggestParsable result = 0;
|
1202 |
|
|
|
1203 |
|
|
// Rejects non-numbers.
|
1204 |
|
|
EXPECT_FALSE(ParseNaturalNumber("non-number string", &result));
|
1205 |
|
|
|
1206 |
|
|
// Rejects numbers with whitespace prefix.
|
1207 |
|
|
EXPECT_FALSE(ParseNaturalNumber(" 123", &result));
|
1208 |
|
|
|
1209 |
|
|
// Rejects negative numbers.
|
1210 |
|
|
EXPECT_FALSE(ParseNaturalNumber("-123", &result));
|
1211 |
|
|
|
1212 |
|
|
// Rejects numbers starting with a plus sign.
|
1213 |
|
|
EXPECT_FALSE(ParseNaturalNumber("+123", &result));
|
1214 |
|
|
errno = 0;
|
1215 |
|
|
}
|
1216 |
|
|
|
1217 |
|
|
TEST(ParseNaturalNumberTest, RejectsOverflownNumbers) {
|
1218 |
|
|
BiggestParsable result = 0;
|
1219 |
|
|
|
1220 |
|
|
EXPECT_FALSE(ParseNaturalNumber("99999999999999999999999", &result));
|
1221 |
|
|
|
1222 |
|
|
signed char char_result = 0;
|
1223 |
|
|
EXPECT_FALSE(ParseNaturalNumber("200", &char_result));
|
1224 |
|
|
errno = 0;
|
1225 |
|
|
}
|
1226 |
|
|
|
1227 |
|
|
TEST(ParseNaturalNumberTest, AcceptsValidNumbers) {
|
1228 |
|
|
BiggestParsable result = 0;
|
1229 |
|
|
|
1230 |
|
|
result = 0;
|
1231 |
|
|
ASSERT_TRUE(ParseNaturalNumber("123", &result));
|
1232 |
|
|
EXPECT_EQ(123U, result);
|
1233 |
|
|
|
1234 |
|
|
// Check 0 as an edge case.
|
1235 |
|
|
result = 1;
|
1236 |
|
|
ASSERT_TRUE(ParseNaturalNumber("0", &result));
|
1237 |
|
|
EXPECT_EQ(0U, result);
|
1238 |
|
|
|
1239 |
|
|
result = 1;
|
1240 |
|
|
ASSERT_TRUE(ParseNaturalNumber("00000", &result));
|
1241 |
|
|
EXPECT_EQ(0U, result);
|
1242 |
|
|
}
|
1243 |
|
|
|
1244 |
|
|
TEST(ParseNaturalNumberTest, AcceptsTypeLimits) {
|
1245 |
|
|
Message msg;
|
1246 |
|
|
msg << kBiggestParsableMax;
|
1247 |
|
|
|
1248 |
|
|
BiggestParsable result = 0;
|
1249 |
|
|
EXPECT_TRUE(ParseNaturalNumber(msg.GetString(), &result));
|
1250 |
|
|
EXPECT_EQ(kBiggestParsableMax, result);
|
1251 |
|
|
|
1252 |
|
|
Message msg2;
|
1253 |
|
|
msg2 << kBiggestSignedParsableMax;
|
1254 |
|
|
|
1255 |
|
|
BiggestSignedParsable signed_result = 0;
|
1256 |
|
|
EXPECT_TRUE(ParseNaturalNumber(msg2.GetString(), &signed_result));
|
1257 |
|
|
EXPECT_EQ(kBiggestSignedParsableMax, signed_result);
|
1258 |
|
|
|
1259 |
|
|
Message msg3;
|
1260 |
|
|
msg3 << INT_MAX;
|
1261 |
|
|
|
1262 |
|
|
int int_result = 0;
|
1263 |
|
|
EXPECT_TRUE(ParseNaturalNumber(msg3.GetString(), &int_result));
|
1264 |
|
|
EXPECT_EQ(INT_MAX, int_result);
|
1265 |
|
|
|
1266 |
|
|
Message msg4;
|
1267 |
|
|
msg4 << UINT_MAX;
|
1268 |
|
|
|
1269 |
|
|
unsigned int uint_result = 0;
|
1270 |
|
|
EXPECT_TRUE(ParseNaturalNumber(msg4.GetString(), &uint_result));
|
1271 |
|
|
EXPECT_EQ(UINT_MAX, uint_result);
|
1272 |
|
|
}
|
1273 |
|
|
|
1274 |
|
|
TEST(ParseNaturalNumberTest, WorksForShorterIntegers) {
|
1275 |
|
|
short short_result = 0;
|
1276 |
|
|
ASSERT_TRUE(ParseNaturalNumber("123", &short_result));
|
1277 |
|
|
EXPECT_EQ(123, short_result);
|
1278 |
|
|
|
1279 |
|
|
signed char char_result = 0;
|
1280 |
|
|
ASSERT_TRUE(ParseNaturalNumber("123", &char_result));
|
1281 |
|
|
EXPECT_EQ(123, char_result);
|
1282 |
|
|
}
|
1283 |
|
|
|
1284 |
|
|
# if GTEST_OS_WINDOWS
|
1285 |
|
|
TEST(EnvironmentTest, HandleFitsIntoSizeT) {
|
1286 |
|
|
// TODO(vladl@google.com): Remove this test after this condition is verified
|
1287 |
|
|
// in a static assertion in gtest-death-test.cc in the function
|
1288 |
|
|
// GetStatusFileDescriptor.
|
1289 |
|
|
ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t));
|
1290 |
|
|
}
|
1291 |
|
|
# endif // GTEST_OS_WINDOWS
|
1292 |
|
|
|
1293 |
|
|
// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED trigger
|
1294 |
|
|
// failures when death tests are available on the system.
|
1295 |
|
|
TEST(ConditionalDeathMacrosDeathTest, ExpectsDeathWhenDeathTestsAvailable) {
|
1296 |
|
|
EXPECT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestExpectMacro"),
|
1297 |
|
|
"death inside CondDeathTestExpectMacro");
|
1298 |
|
|
ASSERT_DEATH_IF_SUPPORTED(DieInside("CondDeathTestAssertMacro"),
|
1299 |
|
|
"death inside CondDeathTestAssertMacro");
|
1300 |
|
|
|
1301 |
|
|
// Empty statement will not crash, which must trigger a failure.
|
1302 |
|
|
EXPECT_NONFATAL_FAILURE(EXPECT_DEATH_IF_SUPPORTED(;, ""), "");
|
1303 |
|
|
EXPECT_FATAL_FAILURE(ASSERT_DEATH_IF_SUPPORTED(;, ""), "");
|
1304 |
|
|
}
|
1305 |
|
|
|
1306 |
|
|
TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) {
|
1307 |
|
|
testing::GTEST_FLAG(death_test_style) = "fast";
|
1308 |
|
|
EXPECT_FALSE(InDeathTestChild());
|
1309 |
|
|
EXPECT_DEATH({
|
1310 |
|
|
fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
|
1311 |
|
|
fflush(stderr);
|
1312 |
|
|
_exit(1);
|
1313 |
|
|
}, "Inside");
|
1314 |
|
|
}
|
1315 |
|
|
|
1316 |
|
|
TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) {
|
1317 |
|
|
testing::GTEST_FLAG(death_test_style) = "threadsafe";
|
1318 |
|
|
EXPECT_FALSE(InDeathTestChild());
|
1319 |
|
|
EXPECT_DEATH({
|
1320 |
|
|
fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
|
1321 |
|
|
fflush(stderr);
|
1322 |
|
|
_exit(1);
|
1323 |
|
|
}, "Inside");
|
1324 |
|
|
}
|
1325 |
|
|
|
1326 |
|
|
#else // !GTEST_HAS_DEATH_TEST follows
|
1327 |
|
|
|
1328 |
|
|
using testing::internal::CaptureStderr;
|
1329 |
|
|
using testing::internal::GetCapturedStderr;
|
1330 |
|
|
|
1331 |
|
|
// Tests that EXPECT_DEATH_IF_SUPPORTED/ASSERT_DEATH_IF_SUPPORTED are still
|
1332 |
|
|
// defined but do not trigger failures when death tests are not available on
|
1333 |
|
|
// the system.
|
1334 |
|
|
TEST(ConditionalDeathMacrosTest, WarnsWhenDeathTestsNotAvailable) {
|
1335 |
|
|
// Empty statement will not crash, but that should not trigger a failure
|
1336 |
|
|
// when death tests are not supported.
|
1337 |
|
|
CaptureStderr();
|
1338 |
|
|
EXPECT_DEATH_IF_SUPPORTED(;, "");
|
1339 |
|
|
std::string output = GetCapturedStderr();
|
1340 |
|
|
ASSERT_TRUE(NULL != strstr(output.c_str(),
|
1341 |
|
|
"Death tests are not supported on this platform"));
|
1342 |
|
|
ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
|
1343 |
|
|
|
1344 |
|
|
// The streamed message should not be printed as there is no test failure.
|
1345 |
|
|
CaptureStderr();
|
1346 |
|
|
EXPECT_DEATH_IF_SUPPORTED(;, "") << "streamed message";
|
1347 |
|
|
output = GetCapturedStderr();
|
1348 |
|
|
ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));
|
1349 |
|
|
|
1350 |
|
|
CaptureStderr();
|
1351 |
|
|
ASSERT_DEATH_IF_SUPPORTED(;, ""); // NOLINT
|
1352 |
|
|
output = GetCapturedStderr();
|
1353 |
|
|
ASSERT_TRUE(NULL != strstr(output.c_str(),
|
1354 |
|
|
"Death tests are not supported on this platform"));
|
1355 |
|
|
ASSERT_TRUE(NULL != strstr(output.c_str(), ";"));
|
1356 |
|
|
|
1357 |
|
|
CaptureStderr();
|
1358 |
|
|
ASSERT_DEATH_IF_SUPPORTED(;, "") << "streamed message"; // NOLINT
|
1359 |
|
|
output = GetCapturedStderr();
|
1360 |
|
|
ASSERT_TRUE(NULL == strstr(output.c_str(), "streamed message"));
|
1361 |
|
|
}
|
1362 |
|
|
|
1363 |
|
|
void FuncWithAssert(int* n) {
|
1364 |
|
|
ASSERT_DEATH_IF_SUPPORTED(return;, "");
|
1365 |
|
|
(*n)++;
|
1366 |
|
|
}
|
1367 |
|
|
|
1368 |
|
|
// Tests that ASSERT_DEATH_IF_SUPPORTED does not return from the current
|
1369 |
|
|
// function (as ASSERT_DEATH does) if death tests are not supported.
|
1370 |
|
|
TEST(ConditionalDeathMacrosTest, AssertDeatDoesNotReturnhIfUnsupported) {
|
1371 |
|
|
int n = 0;
|
1372 |
|
|
FuncWithAssert(&n);
|
1373 |
|
|
EXPECT_EQ(1, n);
|
1374 |
|
|
}
|
1375 |
|
|
|
1376 |
|
|
#endif // !GTEST_HAS_DEATH_TEST
|
1377 |
|
|
|
1378 |
|
|
// Tests that the death test macros expand to code which may or may not
|
1379 |
|
|
// be followed by operator<<, and that in either case the complete text
|
1380 |
|
|
// comprises only a single C++ statement.
|
1381 |
|
|
//
|
1382 |
|
|
// The syntax should work whether death tests are available or not.
|
1383 |
|
|
TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {
|
1384 |
|
|
if (AlwaysFalse())
|
1385 |
|
|
// This would fail if executed; this is a compilation test only
|
1386 |
|
|
ASSERT_DEATH_IF_SUPPORTED(return, "");
|
1387 |
|
|
|
1388 |
|
|
if (AlwaysTrue())
|
1389 |
|
|
EXPECT_DEATH_IF_SUPPORTED(_exit(1), "");
|
1390 |
|
|
else
|
1391 |
|
|
// This empty "else" branch is meant to ensure that EXPECT_DEATH
|
1392 |
|
|
// doesn't expand into an "if" statement without an "else"
|
1393 |
|
|
; // NOLINT
|
1394 |
|
|
|
1395 |
|
|
if (AlwaysFalse())
|
1396 |
|
|
ASSERT_DEATH_IF_SUPPORTED(return, "") << "did not die";
|
1397 |
|
|
|
1398 |
|
|
if (AlwaysFalse())
|
1399 |
|
|
; // NOLINT
|
1400 |
|
|
else
|
1401 |
|
|
EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3;
|
1402 |
|
|
}
|
1403 |
|
|
|
1404 |
|
|
// Tests that conditional death test macros expand to code which interacts
|
1405 |
|
|
// well with switch statements.
|
1406 |
|
|
TEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) {
|
1407 |
|
|
// Microsoft compiler usually complains about switch statements without
|
1408 |
|
|
// case labels. We suppress that warning for this test.
|
1409 |
|
|
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4065)
|
1410 |
|
|
|
1411 |
|
|
switch (0)
|
1412 |
|
|
default:
|
1413 |
|
|
ASSERT_DEATH_IF_SUPPORTED(_exit(1), "")
|
1414 |
|
|
<< "exit in default switch handler";
|
1415 |
|
|
|
1416 |
|
|
switch (0)
|
1417 |
|
|
case 0:
|
1418 |
|
|
EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case";
|
1419 |
|
|
|
1420 |
|
|
GTEST_DISABLE_MSC_WARNINGS_POP_()
|
1421 |
|
|
}
|
1422 |
|
|
|
1423 |
|
|
// Tests that a test case whose name ends with "DeathTest" works fine
|
1424 |
|
|
// on Windows.
|
1425 |
|
|
TEST(NotADeathTest, Test) {
|
1426 |
|
|
SUCCEED();
|
1427 |
|
|
}
|