| // Copyright 2007, Google Inc. |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| // Utilities for testing Google Test itself and code that uses Google Test |
| // (e.g. frameworks built on top of Google Test). |
| |
| #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ |
| #define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ |
| |
| #include "gtest/gtest.h" |
| |
| GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ |
| /* class A needs to have dll-interface to be used by clients of class B */) |
| |
| namespace testing { |
| |
| // This helper class can be used to mock out Google Test failure reporting |
| // so that we can test Google Test or code that builds on Google Test. |
| // |
| // An object of this class appends a TestPartResult object to the |
| // TestPartResultArray object given in the constructor whenever a Google Test |
| // failure is reported. It can either intercept only failures that are |
| // generated in the same thread that created this object or it can intercept |
| // all generated failures. The scope of this mock object can be controlled with |
| // the second argument to the two arguments constructor. |
| class GTEST_API_ ScopedFakeTestPartResultReporter |
| : public TestPartResultReporterInterface { |
| public: |
| // The two possible mocking modes of this object. |
| enum InterceptMode { |
| INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures. |
| INTERCEPT_ALL_THREADS // Intercepts all failures. |
| }; |
| |
| // The c'tor sets this object as the test part result reporter used |
| // by Google Test. The 'result' parameter specifies where to report the |
| // results. This reporter will only catch failures generated in the current |
| // thread. DEPRECATED |
| explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result); |
| |
| // Same as above, but you can choose the interception scope of this object. |
| ScopedFakeTestPartResultReporter(InterceptMode intercept_mode, |
| TestPartResultArray* result); |
| |
| // The d'tor restores the previous test part result reporter. |
| ~ScopedFakeTestPartResultReporter() override; |
| |
| // Appends the TestPartResult object to the TestPartResultArray |
| // received in the constructor. |
| // |
| // This method is from the TestPartResultReporterInterface |
| // interface. |
| void ReportTestPartResult(const TestPartResult& result) override; |
| |
| private: |
| void Init(); |
| |
| const InterceptMode intercept_mode_; |
| TestPartResultReporterInterface* old_reporter_; |
| TestPartResultArray* const result_; |
| |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter); |
| }; |
| |
| namespace internal { |
| |
| // A helper class for implementing EXPECT_FATAL_FAILURE() and |
| // EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given |
| // TestPartResultArray contains exactly one failure that has the given |
| // type and contains the given substring. If that's not the case, a |
| // non-fatal failure will be generated. |
| class GTEST_API_ SingleFailureChecker { |
| public: |
| // The constructor remembers the arguments. |
| SingleFailureChecker(const TestPartResultArray* results, |
| TestPartResult::Type type, const std::string& substr); |
| ~SingleFailureChecker(); |
| |
| private: |
| const TestPartResultArray* const results_; |
| const TestPartResult::Type type_; |
| const std::string substr_; |
| |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker); |
| }; |
| |
| } // namespace internal |
| |
| } // namespace testing |
| |
| GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 |
| |
| // A set of macros for testing Google Test assertions or code that's expected |
| // to generate Google Test fatal failures. It verifies that the given |
| // statement will cause exactly one fatal Google Test failure with 'substr' |
| // being part of the failure message. |
| // |
| // There are two different versions of this macro. EXPECT_FATAL_FAILURE only |
| // affects and considers failures generated in the current thread and |
| // EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. |
| // |
| // The verification of the assertion is done correctly even when the statement |
| // throws an exception or aborts the current function. |
| // |
| // Known restrictions: |
| // - 'statement' cannot reference local non-static variables or |
| // non-static members of the current object. |
| // - 'statement' cannot return a value. |
| // - You cannot stream a failure message to this macro. |
| // |
| // Note that even though the implementations of the following two |
| // macros are much alike, we cannot refactor them to use a common |
| // helper macro, due to some peculiarity in how the preprocessor |
| // works. The AcceptsMacroThatExpandsToUnprotectedComma test in |
| // gtest_unittest.cc will fail to compile if we do that. |
| #define EXPECT_FATAL_FAILURE(statement, substr) \ |
| do { \ |
| class GTestExpectFatalFailureHelper { \ |
| public: \ |
| static void Execute() { statement; } \ |
| }; \ |
| ::testing::TestPartResultArray gtest_failures; \ |
| ::testing::internal::SingleFailureChecker gtest_checker( \ |
| >est_failures, ::testing::TestPartResult::kFatalFailure, (substr)); \ |
| { \ |
| ::testing::ScopedFakeTestPartResultReporter gtest_reporter( \ |
| ::testing::ScopedFakeTestPartResultReporter:: \ |
| INTERCEPT_ONLY_CURRENT_THREAD, \ |
| >est_failures); \ |
| GTestExpectFatalFailureHelper::Execute(); \ |
| } \ |
| } while (::testing::internal::AlwaysFalse()) |
| |
| #define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ |
| do { \ |
| class GTestExpectFatalFailureHelper { \ |
| public: \ |
| static void Execute() { statement; } \ |
| }; \ |
| ::testing::TestPartResultArray gtest_failures; \ |
| ::testing::internal::SingleFailureChecker gtest_checker( \ |
| >est_failures, ::testing::TestPartResult::kFatalFailure, (substr)); \ |
| { \ |
| ::testing::ScopedFakeTestPartResultReporter gtest_reporter( \ |
| ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ |
| >est_failures); \ |
| GTestExpectFatalFailureHelper::Execute(); \ |
| } \ |
| } while (::testing::internal::AlwaysFalse()) |
| |
| // A macro for testing Google Test assertions or code that's expected to |
| // generate Google Test non-fatal failures. It asserts that the given |
| // statement will cause exactly one non-fatal Google Test failure with 'substr' |
| // being part of the failure message. |
| // |
| // There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only |
| // affects and considers failures generated in the current thread and |
| // EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. |
| // |
| // 'statement' is allowed to reference local variables and members of |
| // the current object. |
| // |
| // The verification of the assertion is done correctly even when the statement |
| // throws an exception or aborts the current function. |
| // |
| // Known restrictions: |
| // - You cannot stream a failure message to this macro. |
| // |
| // Note that even though the implementations of the following two |
| // macros are much alike, we cannot refactor them to use a common |
| // helper macro, due to some peculiarity in how the preprocessor |
| // works. If we do that, the code won't compile when the user gives |
| // EXPECT_NONFATAL_FAILURE() a statement that contains a macro that |
| // expands to code containing an unprotected comma. The |
| // AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc |
| // catches that. |
| // |
| // For the same reason, we have to write |
| // if (::testing::internal::AlwaysTrue()) { statement; } |
| // instead of |
| // GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) |
| // to avoid an MSVC warning on unreachable code. |
| #define EXPECT_NONFATAL_FAILURE(statement, substr) \ |
| do { \ |
| ::testing::TestPartResultArray gtest_failures; \ |
| ::testing::internal::SingleFailureChecker gtest_checker( \ |
| >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ |
| (substr)); \ |
| { \ |
| ::testing::ScopedFakeTestPartResultReporter gtest_reporter( \ |
| ::testing::ScopedFakeTestPartResultReporter:: \ |
| INTERCEPT_ONLY_CURRENT_THREAD, \ |
| >est_failures); \ |
| if (::testing::internal::AlwaysTrue()) { \ |
| statement; \ |
| } \ |
| } \ |
| } while (::testing::internal::AlwaysFalse()) |
| |
| #define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ |
| do { \ |
| ::testing::TestPartResultArray gtest_failures; \ |
| ::testing::internal::SingleFailureChecker gtest_checker( \ |
| >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ |
| (substr)); \ |
| { \ |
| ::testing::ScopedFakeTestPartResultReporter gtest_reporter( \ |
| ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ |
| >est_failures); \ |
| if (::testing::internal::AlwaysTrue()) { \ |
| statement; \ |
| } \ |
| } \ |
| } while (::testing::internal::AlwaysFalse()) |
| |
| #endif // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_ |