0
|
1 // Copyright 2006, 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 // This file is AUTOMATICALLY GENERATED on 10/31/2011 by command |
|
31 // 'gen_gtest_pred_impl.py 5'. DO NOT EDIT BY HAND! |
|
32 // |
|
33 // Implements a family of generic predicate assertion macros. |
|
34 |
|
35 #ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ |
|
36 #define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ |
|
37 |
|
38 // Makes sure this header is not included before gtest.h. |
|
39 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_ |
|
40 # error Do not include gtest_pred_impl.h directly. Include gtest.h instead. |
|
41 #endif // GTEST_INCLUDE_GTEST_GTEST_H_ |
|
42 |
|
43 // This header implements a family of generic predicate assertion |
|
44 // macros: |
|
45 // |
|
46 // ASSERT_PRED_FORMAT1(pred_format, v1) |
|
47 // ASSERT_PRED_FORMAT2(pred_format, v1, v2) |
|
48 // ... |
|
49 // |
|
50 // where pred_format is a function or functor that takes n (in the |
|
51 // case of ASSERT_PRED_FORMATn) values and their source expression |
|
52 // text, and returns a testing::AssertionResult. See the definition |
|
53 // of ASSERT_EQ in gtest.h for an example. |
|
54 // |
|
55 // If you don't care about formatting, you can use the more |
|
56 // restrictive version: |
|
57 // |
|
58 // ASSERT_PRED1(pred, v1) |
|
59 // ASSERT_PRED2(pred, v1, v2) |
|
60 // ... |
|
61 // |
|
62 // where pred is an n-ary function or functor that returns bool, |
|
63 // and the values v1, v2, ..., must support the << operator for |
|
64 // streaming to std::ostream. |
|
65 // |
|
66 // We also define the EXPECT_* variations. |
|
67 // |
|
68 // For now we only support predicates whose arity is at most 5. |
|
69 // Please email googletestframework@googlegroups.com if you need |
|
70 // support for higher arities. |
|
71 |
|
72 // GTEST_ASSERT_ is the basic statement to which all of the assertions |
|
73 // in this file reduce. Don't use this in your code. |
|
74 |
|
75 #define GTEST_ASSERT_(expression, on_failure) \ |
|
76 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ |
|
77 if (const ::testing::AssertionResult gtest_ar = (expression)) \ |
|
78 ; \ |
|
79 else \ |
|
80 on_failure(gtest_ar.failure_message()) |
|
81 |
|
82 |
|
83 // Helper function for implementing {EXPECT|ASSERT}_PRED1. Don't use |
|
84 // this in your code. |
|
85 template <typename Pred, |
|
86 typename T1> |
|
87 AssertionResult AssertPred1Helper(const char* pred_text, |
|
88 const char* e1, |
|
89 Pred pred, |
|
90 const T1& v1) { |
|
91 if (pred(v1)) return AssertionSuccess(); |
|
92 |
|
93 return AssertionFailure() << pred_text << "(" |
|
94 << e1 << ") evaluates to false, where" |
|
95 << "\n" << e1 << " evaluates to " << v1; |
|
96 } |
|
97 |
|
98 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1. |
|
99 // Don't use this in your code. |
|
100 #define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\ |
|
101 GTEST_ASSERT_(pred_format(#v1, v1), \ |
|
102 on_failure) |
|
103 |
|
104 // Internal macro for implementing {EXPECT|ASSERT}_PRED1. Don't use |
|
105 // this in your code. |
|
106 #define GTEST_PRED1_(pred, v1, on_failure)\ |
|
107 GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \ |
|
108 #v1, \ |
|
109 pred, \ |
|
110 v1), on_failure) |
|
111 |
|
112 // Unary predicate assertion macros. |
|
113 #define EXPECT_PRED_FORMAT1(pred_format, v1) \ |
|
114 GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) |
|
115 #define EXPECT_PRED1(pred, v1) \ |
|
116 GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_) |
|
117 #define ASSERT_PRED_FORMAT1(pred_format, v1) \ |
|
118 GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) |
|
119 #define ASSERT_PRED1(pred, v1) \ |
|
120 GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_) |
|
121 |
|
122 |
|
123 |
|
124 // Helper function for implementing {EXPECT|ASSERT}_PRED2. Don't use |
|
125 // this in your code. |
|
126 template <typename Pred, |
|
127 typename T1, |
|
128 typename T2> |
|
129 AssertionResult AssertPred2Helper(const char* pred_text, |
|
130 const char* e1, |
|
131 const char* e2, |
|
132 Pred pred, |
|
133 const T1& v1, |
|
134 const T2& v2) { |
|
135 if (pred(v1, v2)) return AssertionSuccess(); |
|
136 |
|
137 return AssertionFailure() << pred_text << "(" |
|
138 << e1 << ", " |
|
139 << e2 << ") evaluates to false, where" |
|
140 << "\n" << e1 << " evaluates to " << v1 |
|
141 << "\n" << e2 << " evaluates to " << v2; |
|
142 } |
|
143 |
|
144 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2. |
|
145 // Don't use this in your code. |
|
146 #define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\ |
|
147 GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \ |
|
148 on_failure) |
|
149 |
|
150 // Internal macro for implementing {EXPECT|ASSERT}_PRED2. Don't use |
|
151 // this in your code. |
|
152 #define GTEST_PRED2_(pred, v1, v2, on_failure)\ |
|
153 GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \ |
|
154 #v1, \ |
|
155 #v2, \ |
|
156 pred, \ |
|
157 v1, \ |
|
158 v2), on_failure) |
|
159 |
|
160 // Binary predicate assertion macros. |
|
161 #define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ |
|
162 GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) |
|
163 #define EXPECT_PRED2(pred, v1, v2) \ |
|
164 GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_) |
|
165 #define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ |
|
166 GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) |
|
167 #define ASSERT_PRED2(pred, v1, v2) \ |
|
168 GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_) |
|
169 |
|
170 |
|
171 |
|
172 // Helper function for implementing {EXPECT|ASSERT}_PRED3. Don't use |
|
173 // this in your code. |
|
174 template <typename Pred, |
|
175 typename T1, |
|
176 typename T2, |
|
177 typename T3> |
|
178 AssertionResult AssertPred3Helper(const char* pred_text, |
|
179 const char* e1, |
|
180 const char* e2, |
|
181 const char* e3, |
|
182 Pred pred, |
|
183 const T1& v1, |
|
184 const T2& v2, |
|
185 const T3& v3) { |
|
186 if (pred(v1, v2, v3)) return AssertionSuccess(); |
|
187 |
|
188 return AssertionFailure() << pred_text << "(" |
|
189 << e1 << ", " |
|
190 << e2 << ", " |
|
191 << e3 << ") evaluates to false, where" |
|
192 << "\n" << e1 << " evaluates to " << v1 |
|
193 << "\n" << e2 << " evaluates to " << v2 |
|
194 << "\n" << e3 << " evaluates to " << v3; |
|
195 } |
|
196 |
|
197 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3. |
|
198 // Don't use this in your code. |
|
199 #define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\ |
|
200 GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \ |
|
201 on_failure) |
|
202 |
|
203 // Internal macro for implementing {EXPECT|ASSERT}_PRED3. Don't use |
|
204 // this in your code. |
|
205 #define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\ |
|
206 GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \ |
|
207 #v1, \ |
|
208 #v2, \ |
|
209 #v3, \ |
|
210 pred, \ |
|
211 v1, \ |
|
212 v2, \ |
|
213 v3), on_failure) |
|
214 |
|
215 // Ternary predicate assertion macros. |
|
216 #define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \ |
|
217 GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_) |
|
218 #define EXPECT_PRED3(pred, v1, v2, v3) \ |
|
219 GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_) |
|
220 #define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \ |
|
221 GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_) |
|
222 #define ASSERT_PRED3(pred, v1, v2, v3) \ |
|
223 GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_) |
|
224 |
|
225 |
|
226 |
|
227 // Helper function for implementing {EXPECT|ASSERT}_PRED4. Don't use |
|
228 // this in your code. |
|
229 template <typename Pred, |
|
230 typename T1, |
|
231 typename T2, |
|
232 typename T3, |
|
233 typename T4> |
|
234 AssertionResult AssertPred4Helper(const char* pred_text, |
|
235 const char* e1, |
|
236 const char* e2, |
|
237 const char* e3, |
|
238 const char* e4, |
|
239 Pred pred, |
|
240 const T1& v1, |
|
241 const T2& v2, |
|
242 const T3& v3, |
|
243 const T4& v4) { |
|
244 if (pred(v1, v2, v3, v4)) return AssertionSuccess(); |
|
245 |
|
246 return AssertionFailure() << pred_text << "(" |
|
247 << e1 << ", " |
|
248 << e2 << ", " |
|
249 << e3 << ", " |
|
250 << e4 << ") evaluates to false, where" |
|
251 << "\n" << e1 << " evaluates to " << v1 |
|
252 << "\n" << e2 << " evaluates to " << v2 |
|
253 << "\n" << e3 << " evaluates to " << v3 |
|
254 << "\n" << e4 << " evaluates to " << v4; |
|
255 } |
|
256 |
|
257 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4. |
|
258 // Don't use this in your code. |
|
259 #define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\ |
|
260 GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \ |
|
261 on_failure) |
|
262 |
|
263 // Internal macro for implementing {EXPECT|ASSERT}_PRED4. Don't use |
|
264 // this in your code. |
|
265 #define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\ |
|
266 GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \ |
|
267 #v1, \ |
|
268 #v2, \ |
|
269 #v3, \ |
|
270 #v4, \ |
|
271 pred, \ |
|
272 v1, \ |
|
273 v2, \ |
|
274 v3, \ |
|
275 v4), on_failure) |
|
276 |
|
277 // 4-ary predicate assertion macros. |
|
278 #define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ |
|
279 GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) |
|
280 #define EXPECT_PRED4(pred, v1, v2, v3, v4) \ |
|
281 GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) |
|
282 #define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ |
|
283 GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) |
|
284 #define ASSERT_PRED4(pred, v1, v2, v3, v4) \ |
|
285 GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) |
|
286 |
|
287 |
|
288 |
|
289 // Helper function for implementing {EXPECT|ASSERT}_PRED5. Don't use |
|
290 // this in your code. |
|
291 template <typename Pred, |
|
292 typename T1, |
|
293 typename T2, |
|
294 typename T3, |
|
295 typename T4, |
|
296 typename T5> |
|
297 AssertionResult AssertPred5Helper(const char* pred_text, |
|
298 const char* e1, |
|
299 const char* e2, |
|
300 const char* e3, |
|
301 const char* e4, |
|
302 const char* e5, |
|
303 Pred pred, |
|
304 const T1& v1, |
|
305 const T2& v2, |
|
306 const T3& v3, |
|
307 const T4& v4, |
|
308 const T5& v5) { |
|
309 if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess(); |
|
310 |
|
311 return AssertionFailure() << pred_text << "(" |
|
312 << e1 << ", " |
|
313 << e2 << ", " |
|
314 << e3 << ", " |
|
315 << e4 << ", " |
|
316 << e5 << ") evaluates to false, where" |
|
317 << "\n" << e1 << " evaluates to " << v1 |
|
318 << "\n" << e2 << " evaluates to " << v2 |
|
319 << "\n" << e3 << " evaluates to " << v3 |
|
320 << "\n" << e4 << " evaluates to " << v4 |
|
321 << "\n" << e5 << " evaluates to " << v5; |
|
322 } |
|
323 |
|
324 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5. |
|
325 // Don't use this in your code. |
|
326 #define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\ |
|
327 GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \ |
|
328 on_failure) |
|
329 |
|
330 // Internal macro for implementing {EXPECT|ASSERT}_PRED5. Don't use |
|
331 // this in your code. |
|
332 #define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\ |
|
333 GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \ |
|
334 #v1, \ |
|
335 #v2, \ |
|
336 #v3, \ |
|
337 #v4, \ |
|
338 #v5, \ |
|
339 pred, \ |
|
340 v1, \ |
|
341 v2, \ |
|
342 v3, \ |
|
343 v4, \ |
|
344 v5), on_failure) |
|
345 |
|
346 // 5-ary predicate assertion macros. |
|
347 #define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ |
|
348 GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) |
|
349 #define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \ |
|
350 GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) |
|
351 #define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ |
|
352 GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) |
|
353 #define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \ |
|
354 GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) |
|
355 |
|
356 |
|
357 |
|
358 #endif // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ |