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 06/22/2008 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>
AssertPred1Helper(const char * pred_text,const char * e1,Pred pred,const T1 & v1)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 Message msg;
94 msg << pred_text << "("
95 << e1 << ") evaluates to false, where"
96 << "\n" << e1 << " evaluates to " << v1;
97 return AssertionFailure(msg);
98 }
99
100 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
101 // Don't use this in your code.
102 #define GTEST_PRED_FORMAT1(pred_format, v1, on_failure)\
103 GTEST_ASSERT(pred_format(#v1, v1),\
104 on_failure)
105
106 // Internal macro for implementing {EXPECT|ASSERT}_PRED1. Don't use
107 // this in your code.
108 #define GTEST_PRED1(pred, v1, on_failure)\
109 GTEST_ASSERT(::testing::AssertPred1Helper(#pred, \
110 #v1, \
111 pred, \
112 v1), on_failure)
113
114 // Unary predicate assertion macros.
115 #define EXPECT_PRED_FORMAT1(pred_format, v1) \
116 GTEST_PRED_FORMAT1(pred_format, v1, GTEST_NONFATAL_FAILURE)
117 #define EXPECT_PRED1(pred, v1) \
118 GTEST_PRED1(pred, v1, GTEST_NONFATAL_FAILURE)
119 #define ASSERT_PRED_FORMAT1(pred_format, v1) \
120 GTEST_PRED_FORMAT1(pred_format, v1, GTEST_FATAL_FAILURE)
121 #define ASSERT_PRED1(pred, v1) \
122 GTEST_PRED1(pred, v1, GTEST_FATAL_FAILURE)
123
124
125
126 // Helper function for implementing {EXPECT|ASSERT}_PRED2. Don't use
127 // this in your code.
128 template <typename Pred,
129 typename T1,
130 typename T2>
AssertPred2Helper(const char * pred_text,const char * e1,const char * e2,Pred pred,const T1 & v1,const T2 & v2)131 AssertionResult AssertPred2Helper(const char* pred_text,
132 const char* e1,
133 const char* e2,
134 Pred pred,
135 const T1& v1,
136 const T2& v2) {
137 if (pred(v1, v2)) return AssertionSuccess();
138
139 Message msg;
140 msg << pred_text << "("
141 << e1 << ", "
142 << e2 << ") evaluates to false, where"
143 << "\n" << e1 << " evaluates to " << v1
144 << "\n" << e2 << " evaluates to " << v2;
145 return AssertionFailure(msg);
146 }
147
148 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
149 // Don't use this in your code.
150 #define GTEST_PRED_FORMAT2(pred_format, v1, v2, on_failure)\
151 GTEST_ASSERT(pred_format(#v1, #v2, v1, v2),\
152 on_failure)
153
154 // Internal macro for implementing {EXPECT|ASSERT}_PRED2. Don't use
155 // this in your code.
156 #define GTEST_PRED2(pred, v1, v2, on_failure)\
157 GTEST_ASSERT(::testing::AssertPred2Helper(#pred, \
158 #v1, \
159 #v2, \
160 pred, \
161 v1, \
162 v2), on_failure)
163
164 // Binary predicate assertion macros.
165 #define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
166 GTEST_PRED_FORMAT2(pred_format, v1, v2, GTEST_NONFATAL_FAILURE)
167 #define EXPECT_PRED2(pred, v1, v2) \
168 GTEST_PRED2(pred, v1, v2, GTEST_NONFATAL_FAILURE)
169 #define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
170 GTEST_PRED_FORMAT2(pred_format, v1, v2, GTEST_FATAL_FAILURE)
171 #define ASSERT_PRED2(pred, v1, v2) \
172 GTEST_PRED2(pred, v1, v2, GTEST_FATAL_FAILURE)
173
174
175
176 // Helper function for implementing {EXPECT|ASSERT}_PRED3. Don't use
177 // this in your code.
178 template <typename Pred,
179 typename T1,
180 typename T2,
181 typename T3>
AssertPred3Helper(const char * pred_text,const char * e1,const char * e2,const char * e3,Pred pred,const T1 & v1,const T2 & v2,const T3 & v3)182 AssertionResult AssertPred3Helper(const char* pred_text,
183 const char* e1,
184 const char* e2,
185 const char* e3,
186 Pred pred,
187 const T1& v1,
188 const T2& v2,
189 const T3& v3) {
190 if (pred(v1, v2, v3)) return AssertionSuccess();
191
192 Message msg;
193 msg << pred_text << "("
194 << e1 << ", "
195 << e2 << ", "
196 << e3 << ") evaluates to false, where"
197 << "\n" << e1 << " evaluates to " << v1
198 << "\n" << e2 << " evaluates to " << v2
199 << "\n" << e3 << " evaluates to " << v3;
200 return AssertionFailure(msg);
201 }
202
203 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
204 // Don't use this in your code.
205 #define GTEST_PRED_FORMAT3(pred_format, v1, v2, v3, on_failure)\
206 GTEST_ASSERT(pred_format(#v1, #v2, #v3, v1, v2, v3),\
207 on_failure)
208
209 // Internal macro for implementing {EXPECT|ASSERT}_PRED3. Don't use
210 // this in your code.
211 #define GTEST_PRED3(pred, v1, v2, v3, on_failure)\
212 GTEST_ASSERT(::testing::AssertPred3Helper(#pred, \
213 #v1, \
214 #v2, \
215 #v3, \
216 pred, \
217 v1, \
218 v2, \
219 v3), on_failure)
220
221 // Ternary predicate assertion macros.
222 #define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
223 GTEST_PRED_FORMAT3(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE)
224 #define EXPECT_PRED3(pred, v1, v2, v3) \
225 GTEST_PRED3(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE)
226 #define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
227 GTEST_PRED_FORMAT3(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE)
228 #define ASSERT_PRED3(pred, v1, v2, v3) \
229 GTEST_PRED3(pred, v1, v2, v3, GTEST_FATAL_FAILURE)
230
231
232
233 // Helper function for implementing {EXPECT|ASSERT}_PRED4. Don't use
234 // this in your code.
235 template <typename Pred,
236 typename T1,
237 typename T2,
238 typename T3,
239 typename T4>
AssertPred4Helper(const char * pred_text,const char * e1,const char * e2,const char * e3,const char * e4,Pred pred,const T1 & v1,const T2 & v2,const T3 & v3,const T4 & v4)240 AssertionResult AssertPred4Helper(const char* pred_text,
241 const char* e1,
242 const char* e2,
243 const char* e3,
244 const char* e4,
245 Pred pred,
246 const T1& v1,
247 const T2& v2,
248 const T3& v3,
249 const T4& v4) {
250 if (pred(v1, v2, v3, v4)) return AssertionSuccess();
251
252 Message msg;
253 msg << pred_text << "("
254 << e1 << ", "
255 << e2 << ", "
256 << e3 << ", "
257 << e4 << ") evaluates to false, where"
258 << "\n" << e1 << " evaluates to " << v1
259 << "\n" << e2 << " evaluates to " << v2
260 << "\n" << e3 << " evaluates to " << v3
261 << "\n" << e4 << " evaluates to " << v4;
262 return AssertionFailure(msg);
263 }
264
265 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
266 // Don't use this in your code.
267 #define GTEST_PRED_FORMAT4(pred_format, v1, v2, v3, v4, on_failure)\
268 GTEST_ASSERT(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4),\
269 on_failure)
270
271 // Internal macro for implementing {EXPECT|ASSERT}_PRED4. Don't use
272 // this in your code.
273 #define GTEST_PRED4(pred, v1, v2, v3, v4, on_failure)\
274 GTEST_ASSERT(::testing::AssertPred4Helper(#pred, \
275 #v1, \
276 #v2, \
277 #v3, \
278 #v4, \
279 pred, \
280 v1, \
281 v2, \
282 v3, \
283 v4), on_failure)
284
285 // 4-ary predicate assertion macros.
286 #define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
287 GTEST_PRED_FORMAT4(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE)
288 #define EXPECT_PRED4(pred, v1, v2, v3, v4) \
289 GTEST_PRED4(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE)
290 #define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
291 GTEST_PRED_FORMAT4(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE)
292 #define ASSERT_PRED4(pred, v1, v2, v3, v4) \
293 GTEST_PRED4(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE)
294
295
296
297 // Helper function for implementing {EXPECT|ASSERT}_PRED5. Don't use
298 // this in your code.
299 template <typename Pred,
300 typename T1,
301 typename T2,
302 typename T3,
303 typename T4,
304 typename T5>
AssertPred5Helper(const char * pred_text,const char * e1,const char * e2,const char * e3,const char * e4,const char * e5,Pred pred,const T1 & v1,const T2 & v2,const T3 & v3,const T4 & v4,const T5 & v5)305 AssertionResult AssertPred5Helper(const char* pred_text,
306 const char* e1,
307 const char* e2,
308 const char* e3,
309 const char* e4,
310 const char* e5,
311 Pred pred,
312 const T1& v1,
313 const T2& v2,
314 const T3& v3,
315 const T4& v4,
316 const T5& v5) {
317 if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
318
319 Message msg;
320 msg << pred_text << "("
321 << e1 << ", "
322 << e2 << ", "
323 << e3 << ", "
324 << e4 << ", "
325 << e5 << ") evaluates to false, where"
326 << "\n" << e1 << " evaluates to " << v1
327 << "\n" << e2 << " evaluates to " << v2
328 << "\n" << e3 << " evaluates to " << v3
329 << "\n" << e4 << " evaluates to " << v4
330 << "\n" << e5 << " evaluates to " << v5;
331 return AssertionFailure(msg);
332 }
333
334 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
335 // Don't use this in your code.
336 #define GTEST_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5, on_failure)\
337 GTEST_ASSERT(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5),\
338 on_failure)
339
340 // Internal macro for implementing {EXPECT|ASSERT}_PRED5. Don't use
341 // this in your code.
342 #define GTEST_PRED5(pred, v1, v2, v3, v4, v5, on_failure)\
343 GTEST_ASSERT(::testing::AssertPred5Helper(#pred, \
344 #v1, \
345 #v2, \
346 #v3, \
347 #v4, \
348 #v5, \
349 pred, \
350 v1, \
351 v2, \
352 v3, \
353 v4, \
354 v5), on_failure)
355
356 // 5-ary predicate assertion macros.
357 #define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
358 GTEST_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE)
359 #define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
360 GTEST_PRED5(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE)
361 #define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
362 GTEST_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE)
363 #define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
364 GTEST_PRED5(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE)
365
366
367
368 #endif // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
369