is Google's (unit) testing and mocking framework for C++ tests.
| gtest-death-test.h (googletest-release-1.11.0) | : | gtest-death-test.h (googletest-release-1.12.0) |
|---|
| | |
| skipping to change at line 30 | | skipping to change at line 30 |
|---|
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| | |
|
| // | | |
| // The Google C++ Testing and Mocking Framework (Google Test) | | // The Google C++ Testing and Mocking Framework (Google Test) |
| // | | // |
| // This header file defines the public API for death tests. It is | | // This header file defines the public API for death tests. It is |
| // #included by gtest.h so a user doesn't need to include this | | // #included by gtest.h so a user doesn't need to include this |
| // directly. | | // directly. |
|
| // GOOGLETEST_CM0001 DO NOT DELETE | | |
| | // IWYU pragma: private, include "gtest/gtest.h" |
| | // IWYU pragma: friend gtest/.* |
| | // IWYU pragma: friend gmock/.* |
| | |
| #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ | | #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ |
| #define GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ | | #define GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ |
| | |
| #include "gtest/internal/gtest-death-test-internal.h" | | #include "gtest/internal/gtest-death-test-internal.h" |
| | |
|
| namespace testing { | | |
| | | |
| // This flag controls the style of death tests. Valid values are "threadsafe", | | // This flag controls the style of death tests. Valid values are "threadsafe", |
| // meaning that the death test child process will re-execute the test binary | | // meaning that the death test child process will re-execute the test binary |
| // from the start, running only a single death test, or "fast", | | // from the start, running only a single death test, or "fast", |
| // meaning that the child process will execute the test logic immediately | | // meaning that the child process will execute the test logic immediately |
| // after forking. | | // after forking. |
| GTEST_DECLARE_string_(death_test_style); | | GTEST_DECLARE_string_(death_test_style); |
| | |
|
| | namespace testing { |
| | |
| #if GTEST_HAS_DEATH_TEST | | #if GTEST_HAS_DEATH_TEST |
| | |
| namespace internal { | | namespace internal { |
| | |
| // Returns a Boolean value indicating whether the caller is currently | | // Returns a Boolean value indicating whether the caller is currently |
| // executing in the context of the death test child process. Tools such as | | // executing in the context of the death test child process. Tools such as |
| // Valgrind heap checkers may need this to modify their behavior in death | | // Valgrind heap checkers may need this to modify their behavior in death |
| // tests. IMPORTANT: This is an internal utility. Using it may break the | | // tests. IMPORTANT: This is an internal utility. Using it may break the |
| // implementation of death tests. User code MUST NOT use it. | | // implementation of death tests. User code MUST NOT use it. |
| GTEST_API_ bool InDeathTestChild(); | | GTEST_API_ bool InDeathTestChild(); |
| | |
| skipping to change at line 106 | | skipping to change at line 108 |
|---|
| // } | | // } |
| // | | // |
| // ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!"); | | // ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!"); |
| // | | // |
| // The final parameter to each of these macros is a matcher applied to any data | | // The final parameter to each of these macros is a matcher applied to any data |
| // the sub-process wrote to stderr. For compatibility with existing tests, a | | // the sub-process wrote to stderr. For compatibility with existing tests, a |
| // bare string is interpreted as a regular expression matcher. | | // bare string is interpreted as a regular expression matcher. |
| // | | // |
| // On the regular expressions used in death tests: | | // On the regular expressions used in death tests: |
| // | | // |
|
| // GOOGLETEST_CM0005 DO NOT DELETE | | |
| // On POSIX-compliant systems (*nix), we use the <regex.h> library, | | // On POSIX-compliant systems (*nix), we use the <regex.h> library, |
| // which uses the POSIX extended regex syntax. | | // which uses the POSIX extended regex syntax. |
| // | | // |
| // On other platforms (e.g. Windows or Mac), we only support a simple regex | | // On other platforms (e.g. Windows or Mac), we only support a simple regex |
| // syntax implemented as part of Google Test. This limited | | // syntax implemented as part of Google Test. This limited |
| // implementation should be enough most of the time when writing | | // implementation should be enough most of the time when writing |
| // death tests; though it lacks many features you can find in PCRE | | // death tests; though it lacks many features you can find in PCRE |
| // or POSIX extended regex syntax. For example, we don't support | | // or POSIX extended regex syntax. For example, we don't support |
| // union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and | | // union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and |
| // repetition count ("x{5,7}"), among others. | | // repetition count ("x{5,7}"), among others. |
| | |
| skipping to change at line 172 | | skipping to change at line 173 |
|---|
| // invoke the test program via a path that contains at least one | | // invoke the test program via a path that contains at least one |
| // path separator (e.g. path/to/foo_test and | | // path separator (e.g. path/to/foo_test and |
| // /absolute/path/to/bar_test are fine, but foo_test is not). This | | // /absolute/path/to/bar_test are fine, but foo_test is not). This |
| // is rarely a problem as people usually don't put the test binary | | // is rarely a problem as people usually don't put the test binary |
| // directory in PATH. | | // directory in PATH. |
| // | | // |
| | |
| // Asserts that a given `statement` causes the program to exit, with an | | // Asserts that a given `statement` causes the program to exit, with an |
| // integer exit status that satisfies `predicate`, and emitting error output | | // integer exit status that satisfies `predicate`, and emitting error output |
| // that matches `matcher`. | | // that matches `matcher`. |
|
| # define ASSERT_EXIT(statement, predicate, matcher) \ | | #define ASSERT_EXIT(statement, predicate, matcher) \ |
| GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_FATAL_FAILURE_) | | GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_FATAL_FAILURE_) |
| | |
| // Like `ASSERT_EXIT`, but continues on to successive tests in the | | // Like `ASSERT_EXIT`, but continues on to successive tests in the |
| // test suite, if any: | | // test suite, if any: |
|
| # define EXPECT_EXIT(statement, predicate, matcher) \ | | #define EXPECT_EXIT(statement, predicate, matcher) \ |
| GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_NONFATAL_FAILURE_) | | GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_NONFATAL_FAILURE_) |
| | |
| // Asserts that a given `statement` causes the program to exit, either by | | // Asserts that a given `statement` causes the program to exit, either by |
| // explicitly exiting with a nonzero exit code or being killed by a | | // explicitly exiting with a nonzero exit code or being killed by a |
| // signal, and emitting error output that matches `matcher`. | | // signal, and emitting error output that matches `matcher`. |
|
| # define ASSERT_DEATH(statement, matcher) \ | | #define ASSERT_DEATH(statement, matcher) \ |
| ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher) | | ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher) |
| | |
| // Like `ASSERT_DEATH`, but continues on to successive tests in the | | // Like `ASSERT_DEATH`, but continues on to successive tests in the |
| // test suite, if any: | | // test suite, if any: |
|
| # define EXPECT_DEATH(statement, matcher) \ | | #define EXPECT_DEATH(statement, matcher) \ |
| EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher) | | EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher) |
| | |
| // Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*: | | // Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*: |
| | |
| // Tests that an exit code describes a normal exit with a given exit code. | | // Tests that an exit code describes a normal exit with a given exit code. |
| class GTEST_API_ ExitedWithCode { | | class GTEST_API_ ExitedWithCode { |
| public: | | public: |
| explicit ExitedWithCode(int exit_code); | | explicit ExitedWithCode(int exit_code); |
| ExitedWithCode(const ExitedWithCode&) = default; | | ExitedWithCode(const ExitedWithCode&) = default; |
| void operator=(const ExitedWithCode& other) = delete; | | void operator=(const ExitedWithCode& other) = delete; |
| bool operator()(int exit_status) const; | | bool operator()(int exit_status) const; |
|
| | |
| private: | | private: |
| const int exit_code_; | | const int exit_code_; |
| }; | | }; |
| | |
|
| # if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA | | #if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA |
| // Tests that an exit code describes an exit due to termination by a | | // Tests that an exit code describes an exit due to termination by a |
| // given signal. | | // given signal. |
|
| // GOOGLETEST_CM0006 DO NOT DELETE | | |
| class GTEST_API_ KilledBySignal { | | class GTEST_API_ KilledBySignal { |
| public: | | public: |
| explicit KilledBySignal(int signum); | | explicit KilledBySignal(int signum); |
| bool operator()(int exit_status) const; | | bool operator()(int exit_status) const; |
|
| | |
| private: | | private: |
| const int signum_; | | const int signum_; |
| }; | | }; |
|
| # endif // !GTEST_OS_WINDOWS | | #endif // !GTEST_OS_WINDOWS |
| | |
| // EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode. | | // EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode. |
| // The death testing framework causes this to have interesting semantics, | | // The death testing framework causes this to have interesting semantics, |
| // since the sideeffects of the call are only visible in opt mode, and not | | // since the sideeffects of the call are only visible in opt mode, and not |
| // in debug mode. | | // in debug mode. |
| // | | // |
| // In practice, this can be used to test functions that utilize the | | // In practice, this can be used to test functions that utilize the |
| // LOG(DFATAL) macro using the following style: | | // LOG(DFATAL) macro using the following style: |
| // | | // |
| // int DieInDebugOr12(int* sideeffect) { | | // int DieInDebugOr12(int* sideeffect) { |
| | |
| skipping to change at line 260 | | skipping to change at line 262 |
|---|
| // need to test that a function has appropriate side-effects in opt | | // need to test that a function has appropriate side-effects in opt |
| // mode, include assertions against the side-effects. A general | | // mode, include assertions against the side-effects. A general |
| // pattern for this is: | | // pattern for this is: |
| // | | // |
| // EXPECT_DEBUG_DEATH({ | | // EXPECT_DEBUG_DEATH({ |
| // // Side-effects here will have an effect after this statement in | | // // Side-effects here will have an effect after this statement in |
| // // opt mode, but none in debug mode. | | // // opt mode, but none in debug mode. |
| // EXPECT_EQ(12, DieInDebugOr12(&sideeffect)); | | // EXPECT_EQ(12, DieInDebugOr12(&sideeffect)); |
| // }, "death"); | | // }, "death"); |
| // | | // |
|
| # ifdef NDEBUG | | #ifdef NDEBUG |
| | |
|
| # define EXPECT_DEBUG_DEATH(statement, regex) \ | | #define EXPECT_DEBUG_DEATH(statement, regex) \ |
| GTEST_EXECUTE_STATEMENT_(statement, regex) | | GTEST_EXECUTE_STATEMENT_(statement, regex) |
| | |
|
| # define ASSERT_DEBUG_DEATH(statement, regex) \ | | #define ASSERT_DEBUG_DEATH(statement, regex) \ |
| GTEST_EXECUTE_STATEMENT_(statement, regex) | | GTEST_EXECUTE_STATEMENT_(statement, regex) |
| | |
|
| # else | | #else |
| | |
|
| # define EXPECT_DEBUG_DEATH(statement, regex) \ | | #define EXPECT_DEBUG_DEATH(statement, regex) EXPECT_DEATH(statement, regex) |
| EXPECT_DEATH(statement, regex) | | |
| | |
|
| # define ASSERT_DEBUG_DEATH(statement, regex) \ | | #define ASSERT_DEBUG_DEATH(statement, regex) ASSERT_DEATH(statement, regex) |
| ASSERT_DEATH(statement, regex) | | |
| | |
|
| # endif // NDEBUG for EXPECT_DEBUG_DEATH | | #endif // NDEBUG for EXPECT_DEBUG_DEATH |
| #endif // GTEST_HAS_DEATH_TEST | | #endif // GTEST_HAS_DEATH_TEST |
| | |
| // This macro is used for implementing macros such as | | // This macro is used for implementing macros such as |
| // EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where | | // EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where |
| // death tests are not supported. Those macros must compile on such systems | | // death tests are not supported. Those macros must compile on such systems |
| // if and only if EXPECT_DEATH and ASSERT_DEATH compile with the same parameters | | // if and only if EXPECT_DEATH and ASSERT_DEATH compile with the same parameters |
| // on systems that support death tests. This allows one to write such a macro on | | // on systems that support death tests. This allows one to write such a macro on |
| // a system that does not support death tests and be sure that it will compile | | // a system that does not support death tests and be sure that it will compile |
| // on a death-test supporting system. It is exposed publicly so that systems | | // on a death-test supporting system. It is exposed publicly so that systems |
| // that have death-tests with stricter requirements than GTEST_HAS_DEATH_TEST | | // that have death-tests with stricter requirements than GTEST_HAS_DEATH_TEST |
| | |
| skipping to change at line 314 | | skipping to change at line 314 |
|---|
| // compile inside functions where ASSERT_DEATH doesn't | | // compile inside functions where ASSERT_DEATH doesn't |
| // compile. | | // compile. |
| // | | // |
| // The branch that has an always false condition is used to ensure that | | // The branch that has an always false condition is used to ensure that |
| // statement and regex are compiled (and thus syntactically correct) but | | // statement and regex are compiled (and thus syntactically correct) but |
| // never executed. The unreachable code macro protects the terminator | | // never executed. The unreachable code macro protects the terminator |
| // statement from generating an 'unreachable code' warning in case | | // statement from generating an 'unreachable code' warning in case |
| // statement unconditionally returns or throws. The Message constructor at | | // statement unconditionally returns or throws. The Message constructor at |
| // the end allows the syntax of streaming additional messages into the | | // the end allows the syntax of streaming additional messages into the |
| // macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH. | | // macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH. |
|
| # define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \ | | #define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \ |
| GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ | | GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ |
| if (::testing::internal::AlwaysTrue()) { \ | | if (::testing::internal::AlwaysTrue()) { \ |
| GTEST_LOG_(WARNING) \ | | GTEST_LOG_(WARNING) << "Death tests are not supported on this platform.\n" \ |
| << "Death tests are not supported on this platform.\n" \ | | << "Statement '" #statement "' cannot be verified."; \ |
| << "Statement '" #statement "' cannot be verified."; \ | | } else if (::testing::internal::AlwaysFalse()) { \ |
| } else if (::testing::internal::AlwaysFalse()) { \ | | ::testing::internal::RE::PartialMatch(".*", (regex)); \ |
| ::testing::internal::RE::PartialMatch(".*", (regex)); \ | | GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ |
| GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ | | terminator; \ |
| terminator; \ | | } else \ |
| } else \ | | ::testing::Message() |
| ::testing::Message() | | |
| | |
| // EXPECT_DEATH_IF_SUPPORTED(statement, regex) and | | // EXPECT_DEATH_IF_SUPPORTED(statement, regex) and |
| // ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if | | // ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if |
| // death tests are supported; otherwise they just issue a warning. This is | | // death tests are supported; otherwise they just issue a warning. This is |
| // useful when you are combining death test assertions with normal test | | // useful when you are combining death test assertions with normal test |
| // assertions in one test. | | // assertions in one test. |
| #if GTEST_HAS_DEATH_TEST | | #if GTEST_HAS_DEATH_TEST |
|
| # define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ | | #define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ |
| EXPECT_DEATH(statement, regex) | | EXPECT_DEATH(statement, regex) |
| # define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ | | #define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ |
| ASSERT_DEATH(statement, regex) | | ASSERT_DEATH(statement, regex) |
| #else | | #else |
|
| # define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ | | #define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ |
| GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, ) | | GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, ) |
| # define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ | | #define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ |
| GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return) | | GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return) |
| #endif | | #endif |
| | |
| } // namespace testing | | } // namespace testing |
| | |
| #endif // GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ | | #endif // GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ |
| | | |
| End of changes. 24 change blocks. |
|---|
| 45 lines changed or deleted | | 44 lines changed or added |
|---|
"Fossies" - the Fresh Open Source Software Archive 