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
40namespace 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.
51class 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
89namespace 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.
96class 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        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
147    {\
148      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
149          ::testing::ScopedFakeTestPartResultReporter:: \
150          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_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        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
164    {\
165      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
166          ::testing::ScopedFakeTestPartResultReporter:: \
167          INTERCEPT_ALL_THREADS, &gtest_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        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
209        (substr));\
210    {\
211      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
212          ::testing::ScopedFakeTestPartResultReporter:: \
213          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_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        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
223        (substr));\
224    {\
225      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
226          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
227          &gtest_failures);\
228      if (::testing::internal::AlwaysTrue()) { statement; }\
229    }\
230  } while (::testing::internal::AlwaysFalse())
231
232#endif  // GTEST_INCLUDE_GTEST_GTEST_SPI_H_
233