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