]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
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 09/24/2010 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_ |