Mercurial > libunicode
comparison gtest/include/gtest/gtest_pred_impl.h @ 4:34a7a99dbcfa
Switch to Boost.Test
author | David Demelier <markand@malikania.fr> |
---|---|
date | Fri, 01 Dec 2017 16:46:31 +0100 |
parents | d9d3406c1250 |
children | ebcc8c9c8831 |
comparison
equal
deleted
inserted
replaced
3:d9d3406c1250 | 4:34a7a99dbcfa |
---|---|
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_ |