0
|
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_ |