1
// Copyright 2007, Google Inc.
2
// All rights reserved.
4
// Redistribution and use in source and binary forms, with or without
5
// modification, are permitted provided that the following conditions are
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
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.
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.
30
// Author: wan@google.com (Zhanyong Wan)
32
// Utilities for testing Google Test itself and code that uses Google Test
33
// (e.g. frameworks built on top of Google Test).
35
#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_
36
#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_
38
#include "gtest/gtest.h"
42
// This helper class can be used to mock out Google Test failure reporting
43
// so that we can test Google Test or code that builds on Google Test.
45
// An object of this class appends a TestPartResult object to the
46
// TestPartResultArray object given in the constructor whenever a Google Test
47
// failure is reported. It can either intercept only failures that are
48
// generated in the same thread that created this object or it can intercept
49
// all generated failures. The scope of this mock object can be controlled with
50
// the second argument to the two arguments constructor.
51
class GTEST_API_ ScopedFakeTestPartResultReporter
52
: public TestPartResultReporterInterface {
54
// The two possible mocking modes of this object.
56
INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures.
57
INTERCEPT_ALL_THREADS // Intercepts all failures.
60
// The c'tor sets this object as the test part result reporter used
61
// by Google Test. The 'result' parameter specifies where to report the
62
// results. This reporter will only catch failures generated in the current
64
explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
66
// Same as above, but you can choose the interception scope of this object.
67
ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
68
TestPartResultArray* result);
70
// The d'tor restores the previous test part result reporter.
71
virtual ~ScopedFakeTestPartResultReporter();
73
// Appends the TestPartResult object to the TestPartResultArray
74
// received in the constructor.
76
// This method is from the TestPartResultReporterInterface
78
virtual void ReportTestPartResult(const TestPartResult& result);
82
const InterceptMode intercept_mode_;
83
TestPartResultReporterInterface* old_reporter_;
84
TestPartResultArray* const result_;
86
GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
91
// A helper class for implementing EXPECT_FATAL_FAILURE() and
92
// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given
93
// TestPartResultArray contains exactly one failure that has the given
94
// type and contains the given substring. If that's not the case, a
95
// non-fatal failure will be generated.
96
class GTEST_API_ SingleFailureChecker {
98
// The constructor remembers the arguments.
99
SingleFailureChecker(const TestPartResultArray* results,
100
TestPartResult::Type type,
101
const string& substr);
102
~SingleFailureChecker();
104
const TestPartResultArray* const results_;
105
const TestPartResult::Type type_;
106
const string substr_;
108
GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
111
} // namespace internal
113
} // namespace testing
115
// A set of macros for testing Google Test assertions or code that's expected
116
// to generate Google Test fatal failures. It verifies that the given
117
// statement will cause exactly one fatal Google Test failure with 'substr'
118
// being part of the failure message.
120
// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
121
// affects and considers failures generated in the current thread and
122
// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
124
// The verification of the assertion is done correctly even when the statement
125
// throws an exception or aborts the current function.
127
// Known restrictions:
128
// - 'statement' cannot reference local non-static variables or
129
// non-static members of the current object.
130
// - 'statement' cannot return a value.
131
// - You cannot stream a failure message to this macro.
133
// Note that even though the implementations of the following two
134
// macros are much alike, we cannot refactor them to use a common
135
// helper macro, due to some peculiarity in how the preprocessor
136
// works. The AcceptsMacroThatExpandsToUnprotectedComma test in
137
// gtest_unittest.cc will fail to compile if we do that.
138
#define EXPECT_FATAL_FAILURE(statement, substr) \
140
class GTestExpectFatalFailureHelper {\
142
static void Execute() { statement; }\
144
::testing::TestPartResultArray gtest_failures;\
145
::testing::internal::SingleFailureChecker gtest_checker(\
146
>est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
148
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
149
::testing::ScopedFakeTestPartResultReporter:: \
150
INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\
151
GTestExpectFatalFailureHelper::Execute();\
153
} while (::testing::internal::AlwaysFalse())
155
#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
157
class GTestExpectFatalFailureHelper {\
159
static void Execute() { statement; }\
161
::testing::TestPartResultArray gtest_failures;\
162
::testing::internal::SingleFailureChecker gtest_checker(\
163
>est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
165
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
166
::testing::ScopedFakeTestPartResultReporter:: \
167
INTERCEPT_ALL_THREADS, >est_failures);\
168
GTestExpectFatalFailureHelper::Execute();\
170
} while (::testing::internal::AlwaysFalse())
172
// A macro for testing Google Test assertions or code that's expected to
173
// generate Google Test non-fatal failures. It asserts that the given
174
// statement will cause exactly one non-fatal Google Test failure with 'substr'
175
// being part of the failure message.
177
// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
178
// affects and considers failures generated in the current thread and
179
// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
181
// 'statement' is allowed to reference local variables and members of
182
// the current object.
184
// The verification of the assertion is done correctly even when the statement
185
// throws an exception or aborts the current function.
187
// Known restrictions:
188
// - You cannot stream a failure message to this macro.
190
// Note that even though the implementations of the following two
191
// macros are much alike, we cannot refactor them to use a common
192
// helper macro, due to some peculiarity in how the preprocessor
193
// works. If we do that, the code won't compile when the user gives
194
// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
195
// expands to code containing an unprotected comma. The
196
// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
199
// For the same reason, we have to write
200
// if (::testing::internal::AlwaysTrue()) { statement; }
202
// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
203
// to avoid an MSVC warning on unreachable code.
204
#define EXPECT_NONFATAL_FAILURE(statement, substr) \
206
::testing::TestPartResultArray gtest_failures;\
207
::testing::internal::SingleFailureChecker gtest_checker(\
208
>est_failures, ::testing::TestPartResult::kNonFatalFailure, \
211
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
212
::testing::ScopedFakeTestPartResultReporter:: \
213
INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\
214
if (::testing::internal::AlwaysTrue()) { statement; }\
216
} while (::testing::internal::AlwaysFalse())
218
#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
220
::testing::TestPartResultArray gtest_failures;\
221
::testing::internal::SingleFailureChecker gtest_checker(\
222
>est_failures, ::testing::TestPartResult::kNonFatalFailure, \
225
::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
226
::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
228
if (::testing::internal::AlwaysTrue()) { statement; }\
230
} while (::testing::internal::AlwaysFalse())
232
#endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
added
removed
3rd_party/gmock/gtest/include/gtest/gtest-spi.h
