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 // Author: wan@google.com (Zhanyong Wan) 31 // 32 // Utilities for testing Google Test itself and code that uses Google Test 33 // (e.g. frameworks built on top of Google Test). 34 35 #ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_ 36 #define GTEST_INCLUDE_GTEST_GTEST_SPI_H_ 37 38 #include "gtest/gtest.h" 39 40 namespace testing { 41 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. 44 // 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 { 53 public: 54 // The two possible mocking modes of this object. 55 enum InterceptMode { 56 INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures. 57 INTERCEPT_ALL_THREADS // Intercepts all failures. 58 }; 59 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 63 // thread. DEPRECATED 64 explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result); 65 66 // Same as above, but you can choose the interception scope of this object. 67 ScopedFakeTestPartResultReporter(InterceptMode intercept_mode, 68 TestPartResultArray* result); 69 70 // The d'tor restores the previous test part result reporter. 71 virtual ~ScopedFakeTestPartResultReporter(); 72 73 // Appends the TestPartResult object to the TestPartResultArray 74 // received in the constructor. 75 // 76 // This method is from the TestPartResultReporterInterface 77 // interface. 78 virtual void ReportTestPartResult(const TestPartResult& result); 79 private: 80 void Init(); 81 82 const InterceptMode intercept_mode_; 83 TestPartResultReporterInterface* old_reporter_; 84 TestPartResultArray* const result_; 85 86 GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter); 87 }; 88 89 namespace internal { 90 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 { 97 public: 98 // The constructor remembers the arguments. 99 SingleFailureChecker(const TestPartResultArray* results, 100 TestPartResult::Type type, 101 const string& substr); 102 ~SingleFailureChecker(); 103 private: 104 const TestPartResultArray* const results_; 105 const TestPartResult::Type type_; 106 const string substr_; 107 108 GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker); 109 }; 110 111 } // namespace internal 112 113 } // namespace testing 114 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. 119 // 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. 123 // 124 // The verification of the assertion is done correctly even when the statement 125 // throws an exception or aborts the current function. 126 // 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. 132 // 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) \ 139 do { \ 140 class GTestExpectFatalFailureHelper {\ 141 public:\ 142 static void Execute() { statement; }\ 143 };\ 144 ::testing::TestPartResultArray gtest_failures;\ 145 ::testing::internal::SingleFailureChecker gtest_checker(\ 146 >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ 147 {\ 148 ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ 149 ::testing::ScopedFakeTestPartResultReporter:: \ 150 INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ 151 GTestExpectFatalFailureHelper::Execute();\ 152 }\ 153 } while (::testing::internal::AlwaysFalse()) 154 155 #define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ 156 do { \ 157 class GTestExpectFatalFailureHelper {\ 158 public:\ 159 static void Execute() { statement; }\ 160 };\ 161 ::testing::TestPartResultArray gtest_failures;\ 162 ::testing::internal::SingleFailureChecker gtest_checker(\ 163 >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ 164 {\ 165 ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ 166 ::testing::ScopedFakeTestPartResultReporter:: \ 167 INTERCEPT_ALL_THREADS, >est_failures);\ 168 GTestExpectFatalFailureHelper::Execute();\ 169 }\ 170 } while (::testing::internal::AlwaysFalse()) 171 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. 176 // 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. 180 // 181 // 'statement' is allowed to reference local variables and members of 182 // the current object. 183 // 184 // The verification of the assertion is done correctly even when the statement 185 // throws an exception or aborts the current function. 186 // 187 // Known restrictions: 188 // - You cannot stream a failure message to this macro. 189 // 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 197 // catches that. 198 // 199 // For the same reason, we have to write 200 // if (::testing::internal::AlwaysTrue()) { statement; } 201 // instead of 202 // GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) 203 // to avoid an MSVC warning on unreachable code. 204 #define EXPECT_NONFATAL_FAILURE(statement, substr) \ 205 do {\ 206 ::testing::TestPartResultArray gtest_failures;\ 207 ::testing::internal::SingleFailureChecker gtest_checker(\ 208 >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ 209 (substr));\ 210 {\ 211 ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ 212 ::testing::ScopedFakeTestPartResultReporter:: \ 213 INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ 214 if (::testing::internal::AlwaysTrue()) { statement; }\ 215 }\ 216 } while (::testing::internal::AlwaysFalse()) 217 218 #define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ 219 do {\ 220 ::testing::TestPartResultArray gtest_failures;\ 221 ::testing::internal::SingleFailureChecker gtest_checker(\ 222 >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ 223 (substr));\ 224 {\ 225 ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ 226 ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ 227 >est_failures);\ 228 if (::testing::internal::AlwaysTrue()) { statement; }\ 229 }\ 230 } while (::testing::internal::AlwaysFalse()) 231 232 #endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_ 233