| 1 |
// Copyright 2007, 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 |
// Utilities for testing Google Test itself and code that uses Google Test |
| 31 |
// (e.g. frameworks built on top of Google Test). |
| 32 |
|
| 33 |
#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ |
| 34 |
#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ |
| 35 |
|
| 36 |
#include <string> |
| 37 |
|
| 38 |
#include "gtest/gtest.h" |
| 39 |
|
| 40 |
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ |
| 41 |
/* class A needs to have dll-interface to be used by clients of class B */) |
| 42 |
|
| 43 |
namespace testing { |
| 44 |
|
| 45 |
// This helper class can be used to mock out Google Test failure reporting |
| 46 |
// so that we can test Google Test or code that builds on Google Test. |
| 47 |
// |
| 48 |
// An object of this class appends a TestPartResult object to the |
| 49 |
// TestPartResultArray object given in the constructor whenever a Google Test |
| 50 |
// failure is reported. It can either intercept only failures that are |
| 51 |
// generated in the same thread that created this object or it can intercept |
| 52 |
// all generated failures. The scope of this mock object can be controlled with |
| 53 |
// the second argument to the two arguments constructor. |
| 54 |
class GTEST_API_ ScopedFakeTestPartResultReporter |
| 55 |
: public TestPartResultReporterInterface { |
| 56 |
public: |
| 57 |
// The two possible mocking modes of this object. |
| 58 |
enum InterceptMode { |
| 59 |
INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures. |
| 60 |
INTERCEPT_ALL_THREADS // Intercepts all failures. |
| 61 |
}; |
| 62 |
|
| 63 |
// The c'tor sets this object as the test part result reporter used |
| 64 |
// by Google Test. The 'result' parameter specifies where to report the |
| 65 |
// results. This reporter will only catch failures generated in the current |
| 66 |
// thread. DEPRECATED |
| 67 |
explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result); |
| 68 |
|
| 69 |
// Same as above, but you can choose the interception scope of this object. |
| 70 |
ScopedFakeTestPartResultReporter(InterceptMode intercept_mode, |
| 71 |
TestPartResultArray* result); |
| 72 |
|
| 73 |
// The d'tor restores the previous test part result reporter. |
| 74 |
~ScopedFakeTestPartResultReporter() override; |
| 75 |
|
| 76 |
// Appends the TestPartResult object to the TestPartResultArray |
| 77 |
// received in the constructor. |
| 78 |
// |
| 79 |
// This method is from the TestPartResultReporterInterface |
| 80 |
// interface. |
| 81 |
void ReportTestPartResult(const TestPartResult& result) override; |
| 82 |
|
| 83 |
private: |
| 84 |
void Init(); |
| 85 |
|
| 86 |
const InterceptMode intercept_mode_; |
| 87 |
TestPartResultReporterInterface* old_reporter_; |
| 88 |
TestPartResultArray* const result_; |
| 89 |
|
| 90 |
ScopedFakeTestPartResultReporter(const ScopedFakeTestPartResultReporter&) = |
| 91 |
delete; |
| 92 |
ScopedFakeTestPartResultReporter& operator=( |
| 93 |
const ScopedFakeTestPartResultReporter&) = delete; |
| 94 |
}; |
| 95 |
|
| 96 |
namespace internal { |
| 97 |
|
| 98 |
// A helper class for implementing EXPECT_FATAL_FAILURE() and |
| 99 |
// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given |
| 100 |
// TestPartResultArray contains exactly one failure that has the given |
| 101 |
// type and contains the given substring. If that's not the case, a |
| 102 |
// non-fatal failure will be generated. |
| 103 |
class GTEST_API_ SingleFailureChecker { |
| 104 |
public: |
| 105 |
// The constructor remembers the arguments. |
| 106 |
SingleFailureChecker(const TestPartResultArray* results, |
| 107 |
TestPartResult::Type type, const std::string& substr); |
| 108 |
~SingleFailureChecker(); |
| 109 |
|
| 110 |
private: |
| 111 |
const TestPartResultArray* const results_; |
| 112 |
const TestPartResult::Type type_; |
| 113 |
const std::string substr_; |
| 114 |
|
| 115 |
SingleFailureChecker(const SingleFailureChecker&) = delete; |
| 116 |
SingleFailureChecker& operator=(const SingleFailureChecker&) = delete; |
| 117 |
}; |
| 118 |
|
| 119 |
} // namespace internal |
| 120 |
|
| 121 |
} // namespace testing |
| 122 |
|
| 123 |
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 |
| 124 |
|
| 125 |
// A set of macros for testing Google Test assertions or code that's expected |
| 126 |
// to generate Google Test fatal failures (e.g. a failure from an ASSERT_EQ, but |
| 127 |
// not a non-fatal failure, as from EXPECT_EQ). It verifies that the given |
| 128 |
// statement will cause exactly one fatal Google Test failure with 'substr' |
| 129 |
// being part of the failure message. |
| 130 |
// |
| 131 |
// There are two different versions of this macro. EXPECT_FATAL_FAILURE only |
| 132 |
// affects and considers failures generated in the current thread and |
| 133 |
// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. |
| 134 |
// |
| 135 |
// The verification of the assertion is done correctly even when the statement |
| 136 |
// throws an exception or aborts the current function. |
| 137 |
// |
| 138 |
// Known restrictions: |
| 139 |
// - 'statement' cannot reference local non-static variables or |
| 140 |
// non-static members of the current object. |
| 141 |
// - 'statement' cannot return a value. |
| 142 |
// - You cannot stream a failure message to this macro. |
| 143 |
// |
| 144 |
// Note that even though the implementations of the following two |
| 145 |
// macros are much alike, we cannot refactor them to use a common |
| 146 |
// helper macro, due to some peculiarity in how the preprocessor |
| 147 |
// works. The AcceptsMacroThatExpandsToUnprotectedComma test in |
| 148 |
// gtest_unittest.cc will fail to compile if we do that. |
| 149 |
#define EXPECT_FATAL_FAILURE(statement, substr) \ |
| 150 |
do { \ |
| 151 |
class GTestExpectFatalFailureHelper { \ |
| 152 |
public: \ |
| 153 |
static void Execute() { statement; } \ |
| 154 |
}; \ |
| 155 |
::testing::TestPartResultArray gtest_failures; \ |
| 156 |
::testing::internal::SingleFailureChecker gtest_checker( \ |
| 157 |
>est_failures, ::testing::TestPartResult::kFatalFailure, (substr)); \ |
| 158 |
{ \ |
| 159 |
::testing::ScopedFakeTestPartResultReporter gtest_reporter( \ |
| 160 |
::testing::ScopedFakeTestPartResultReporter:: \ |
| 161 |
INTERCEPT_ONLY_CURRENT_THREAD, \ |
| 162 |
>est_failures); \ |
| 163 |
GTestExpectFatalFailureHelper::Execute(); \ |
| 164 |
} \ |
| 165 |
} while (::testing::internal::AlwaysFalse()) |
| 166 |
|
| 167 |
#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ |
| 168 |
do { \ |
| 169 |
class GTestExpectFatalFailureHelper { \ |
| 170 |
public: \ |
| 171 |
static void Execute() { statement; } \ |
| 172 |
}; \ |
| 173 |
::testing::TestPartResultArray gtest_failures; \ |
| 174 |
::testing::internal::SingleFailureChecker gtest_checker( \ |
| 175 |
>est_failures, ::testing::TestPartResult::kFatalFailure, (substr)); \ |
| 176 |
{ \ |
| 177 |
::testing::ScopedFakeTestPartResultReporter gtest_reporter( \ |
| 178 |
::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ |
| 179 |
>est_failures); \ |
| 180 |
GTestExpectFatalFailureHelper::Execute(); \ |
| 181 |
} \ |
| 182 |
} while (::testing::internal::AlwaysFalse()) |
| 183 |
|
| 184 |
// A macro for testing Google Test assertions or code that's expected to |
| 185 |
// generate Google Test non-fatal failures (e.g. a failure from an EXPECT_EQ, |
| 186 |
// but not from an ASSERT_EQ). It asserts that the given statement will cause |
| 187 |
// exactly one non-fatal Google Test failure with 'substr' being part of the |
| 188 |
// failure message. |
| 189 |
// |
| 190 |
// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only |
| 191 |
// affects and considers failures generated in the current thread and |
| 192 |
// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. |
| 193 |
// |
| 194 |
// 'statement' is allowed to reference local variables and members of |
| 195 |
// the current object. |
| 196 |
// |
| 197 |
// The verification of the assertion is done correctly even when the statement |
| 198 |
// throws an exception or aborts the current function. |
| 199 |
// |
| 200 |
// Known restrictions: |
| 201 |
// - You cannot stream a failure message to this macro. |
| 202 |
// |
| 203 |
// Note that even though the implementations of the following two |
| 204 |
// macros are much alike, we cannot refactor them to use a common |
| 205 |
// helper macro, due to some peculiarity in how the preprocessor |
| 206 |
// works. If we do that, the code won't compile when the user gives |
| 207 |
// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that |
| 208 |
// expands to code containing an unprotected comma. The |
| 209 |
// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc |
| 210 |
// catches that. |
| 211 |
// |
| 212 |
// For the same reason, we have to write |
| 213 |
// if (::testing::internal::AlwaysTrue()) { statement; } |
| 214 |
// instead of |
| 215 |
// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) |
| 216 |
// to avoid an MSVC warning on unreachable code. |
| 217 |
#define EXPECT_NONFATAL_FAILURE(statement, substr) \ |
| 218 |
do { \ |
| 219 |
::testing::TestPartResultArray gtest_failures; \ |
| 220 |
::testing::internal::SingleFailureChecker gtest_checker( \ |
| 221 |
>est_failures, ::testing::TestPartResult::kNonFatalFailure, \ |
| 222 |
(substr)); \ |
| 223 |
{ \ |
| 224 |
::testing::ScopedFakeTestPartResultReporter gtest_reporter( \ |
| 225 |
::testing::ScopedFakeTestPartResultReporter:: \ |
| 226 |
INTERCEPT_ONLY_CURRENT_THREAD, \ |
| 227 |
>est_failures); \ |
| 228 |
if (::testing::internal::AlwaysTrue()) { \ |
| 229 |
statement; \ |
| 230 |
} \ |
| 231 |
} \ |
| 232 |
} while (::testing::internal::AlwaysFalse()) |
| 233 |
|
| 234 |
#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ |
| 235 |
do { \ |
| 236 |
::testing::TestPartResultArray gtest_failures; \ |
| 237 |
::testing::internal::SingleFailureChecker gtest_checker( \ |
| 238 |
>est_failures, ::testing::TestPartResult::kNonFatalFailure, \ |
| 239 |
(substr)); \ |
| 240 |
{ \ |
| 241 |
::testing::ScopedFakeTestPartResultReporter gtest_reporter( \ |
| 242 |
::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ |
| 243 |
>est_failures); \ |
| 244 |
if (::testing::internal::AlwaysTrue()) { \ |
| 245 |
statement; \ |
| 246 |
} \ |
| 247 |
} \ |
| 248 |
} while (::testing::internal::AlwaysFalse()) |
| 249 |
|
| 250 |
#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ |