1 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  *  Copyright (C) 2007-2014  Kouhei Sutou <kou@clear-code.com>
4  *
5  *  This library is free software: you can redistribute it and/or modify
6  *  it under the terms of the GNU Lesser General Public License as published by
7  *  the Free Software Foundation, either version 3 of the License, or
8  *  (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU Lesser General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Lesser General Public License
16  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  *
18  */
19 
20 #ifndef __CUT_ASSERTIONS_HELPER_H__
21 #define __CUT_ASSERTIONS_HELPER_H__
22 
23 #include <cutter/cut-public.h>
24 #include <cutter/cut-test-utils.h>
25 
26 #ifdef __cplusplus
27 extern "C" {
28 #endif
29 
30 #define cut_test_with_user_message(assertion, set_user_message) do      \
31 {                                                                       \
32     jmp_buf *cut_previous_jump_buffer;                                  \
33     jmp_buf cut_jump_buffer;                                            \
34                                                                         \
35     cut_test_context_start_user_message_jump(cut_get_current_test_context()); \
36     cut_previous_jump_buffer =                                          \
37         cut_test_context_get_jump_buffer(cut_get_current_test_context()); \
38     cut_test_context_set_jump_buffer(cut_get_current_test_context(),    \
39                                      &cut_jump_buffer);                 \
40     if (setjmp(cut_jump_buffer) == 0) {                                 \
41         assertion;                                                      \
42     }                                                                   \
43     cut_test_context_set_jump_buffer(cut_get_current_test_context(),    \
44                                      cut_previous_jump_buffer);         \
45     cut_test_context_finish_user_message_jump(cut_get_current_test_context()); \
46                                                                         \
47     do {                                                                \
48         set_user_message;                                               \
49     } while (0);                                                        \
50                                                                         \
51     if (cut_test_context_get_have_current_result(cut_get_current_test_context())) { \
52         if (!cut_test_context_in_user_message_jump(cut_get_current_test_context())) { \
53             cut_test_context_process_current_result(cut_get_current_test_context()); \
54         }                                                               \
55         cut_return();                                                   \
56     }                                                                   \
57 } while (0)
58 
59 #define cut_test_register_result(status, system_message, ...) do        \
60 {                                                                       \
61     cut_test_context_set_current_result(cut_get_current_test_context(), \
62                                         CUT_TEST_RESULT_ ## status,     \
63                                         system_message);                \
64     do {                                                                \
65         __VA_ARGS__;                                                    \
66     } while (0);                                                        \
67     cut_test_context_process_current_result(cut_get_current_test_context()); \
68 } while (0)
69 
70 #define cut_test_terminate(status, system_message, ...) do              \
71 {                                                                       \
72     cut_test_context_set_current_result(cut_get_current_test_context(), \
73                                         CUT_TEST_RESULT_ ## status,     \
74                                         system_message);                \
75     do {                                                                \
76         __VA_ARGS__;                                                    \
77     } while (0);                                                        \
78     if (!cut_test_context_in_user_message_jump(cut_get_current_test_context())) { \
79         cut_test_context_process_current_result(cut_get_current_test_context()); \
80     }                                                                   \
81     cut_return();                                                       \
82 } while (0)
83 
84 void        cut_assert_helper              (cut_boolean     result,
85                                             const char     *expression);
86 void        cut_assert_true_helper         (cut_boolean     result,
87                                             const char     *expression);
88 void        cut_assert_false_helper        (cut_boolean     result,
89                                             const char     *expression);
90 void        cut_assert_equal_boolean_helper(cut_boolean     expected,
91                                             cut_boolean     actual,
92                                             const char     *expression_expected,
93                                             const char     *expression_actual);
94 void        cut_assert_not_equal_boolean_helper
95                                            (cut_boolean     expected,
96                                             cut_boolean     actual,
97                                             const char     *expression_expected,
98                                             const char     *expression_actual);
99 void        cut_assert_null_helper         (const void     *object,
100                                             const char     *expression);
101 void        cut_assert_null_string_helper  (const char     *string,
102                                             const char     *expression);
103 void        cut_assert_not_null_helper     (const void     *object,
104                                             const char     *expression);
105 void        cut_assert_equal_int_helper    (long            expected,
106                                             long            actual,
107                                             const char     *expression_expected,
108                                             const char     *expression_actual);
109 void        cut_assert_not_equal_int_helper(long            expected,
110                                             long            actual,
111                                             const char     *expression_expected,
112                                             const char     *expression_actual);
113 #ifdef HAVE_STDINT_H
114 void        cut_assert_equal_int_least8_helper
115                                            (int_least8_t    expected,
116                                             int_least8_t    actual,
117                                             const char     *expression_expected,
118                                             const char     *expression_actual);
119 void        cut_assert_not_equal_int_least8_helper
120                                            (int_least8_t    expected,
121                                             int_least8_t    actual,
122                                             const char     *expression_expected,
123                                             const char     *expression_actual);
124 void        cut_assert_equal_int_least16_helper
125                                            (int_least16_t   expected,
126                                             int_least16_t   actual,
127                                             const char     *expression_expected,
128                                             const char     *expression_actual);
129 void        cut_assert_not_equal_int_least16_helper
130                                            (int_least16_t   expected,
131                                             int_least16_t   actual,
132                                             const char     *expression_expected,
133                                             const char     *expression_actual);
134 void        cut_assert_equal_int_least32_helper
135                                            (int_least32_t   expected,
136                                             int_least32_t   actual,
137                                             const char     *expression_expected,
138                                             const char     *expression_actual);
139 void        cut_assert_not_equal_int_least32_helper
140                                            (int_least32_t   expected,
141                                             int_least32_t   actual,
142                                             const char     *expression_expected,
143                                             const char     *expression_actual);
144 void        cut_assert_equal_int_least64_helper
145                                            (int_least64_t   expected,
146                                             int_least64_t   actual,
147                                             const char     *expression_expected,
148                                             const char     *expression_actual);
149 void        cut_assert_not_equal_int_least64_helper
150                                            (int_least64_t   expected,
151                                             int_least64_t   actual,
152                                             const char     *expression_expected,
153                                             const char     *expression_actual);
154 void        cut_assert_equal_int_fast8_helper
155                                            (int_fast8_t     expected,
156                                             int_fast8_t     actual,
157                                             const char     *expression_expected,
158                                             const char     *expression_actual);
159 void        cut_assert_not_equal_int_fast8_helper
160                                            (int_fast8_t     expected,
161                                             int_fast8_t     actual,
162                                             const char     *expression_expected,
163                                             const char     *expression_actual);
164 void        cut_assert_equal_int_fast16_helper
165                                            (int_fast16_t    expected,
166                                             int_fast16_t    actual,
167                                             const char     *expression_expected,
168                                             const char     *expression_actual);
169 void        cut_assert_not_equal_int_fast16_helper
170                                            (int_fast16_t    expected,
171                                             int_fast16_t    actual,
172                                             const char     *expression_expected,
173                                             const char     *expression_actual);
174 void        cut_assert_equal_int_fast32_helper
175                                            (int_fast32_t    expected,
176                                             int_fast32_t    actual,
177                                             const char     *expression_expected,
178                                             const char     *expression_actual);
179 void        cut_assert_not_equal_int_fast32_helper
180                                            (int_fast32_t    expected,
181                                             int_fast32_t    actual,
182                                             const char     *expression_expected,
183                                             const char     *expression_actual);
184 void        cut_assert_equal_int_fast64_helper
185                                            (int_fast64_t    expected,
186                                             int_fast64_t    actual,
187                                             const char     *expression_expected,
188                                             const char     *expression_actual);
189 void        cut_assert_not_equal_int_fast64_helper
190                                            (int_fast64_t    expected,
191                                             int_fast64_t    actual,
192                                             const char     *expression_expected,
193                                             const char     *expression_actual);
194 void        cut_assert_equal_intptr_helper (intptr_t        expected,
195                                             intptr_t        actual,
196                                             const char     *expression_expected,
197                                             const char     *expression_actual);
198 void        cut_assert_not_equal_intptr_helper
199                                            (intptr_t        expected,
200                                             intptr_t        actual,
201                                             const char     *expression_expected,
202                                             const char     *expression_actual);
203 void        cut_assert_equal_intmax_helper (intmax_t        expected,
204                                             intmax_t        actual,
205                                             const char     *expression_expected,
206                                             const char     *expression_actual);
207 void        cut_assert_not_equal_intmax_helper
208                                            (intmax_t        expected,
209                                             intmax_t        actual,
210                                             const char     *expression_expected,
211                                             const char     *expression_actual);
212 #endif
213 void        cut_assert_equal_uint_helper   (unsigned long   expected,
214                                             unsigned long   actual,
215                                             const char     *expression_expected,
216                                             const char     *expression_actual);
217 void        cut_assert_not_equal_uint_helper
218                                            (unsigned long   expected,
219                                             unsigned long   actual,
220                                             const char     *expression_expected,
221                                             const char     *expression_actual);
222 #ifdef HAVE_STDINT_H
223 void        cut_assert_equal_uint_least8_helper
224                                            (uint_least8_t   expected,
225                                             uint_least8_t   actual,
226                                             const char     *expression_expected,
227                                             const char     *expression_actual);
228 void        cut_assert_not_equal_uint_least8_helper
229                                            (uint_least8_t   expected,
230                                             uint_least8_t   actual,
231                                             const char     *expression_expected,
232                                             const char     *expression_actual);
233 void        cut_assert_equal_uint_least16_helper
234                                            (uint_least16_t  expected,
235                                             uint_least16_t  actual,
236                                             const char     *expression_expected,
237                                             const char     *expression_actual);
238 void        cut_assert_not_equal_uint_least16_helper
239                                            (uint_least16_t  expected,
240                                             uint_least16_t  actual,
241                                             const char     *expression_expected,
242                                             const char     *expression_actual);
243 void        cut_assert_equal_uint_least32_helper
244                                            (uint_least32_t  expected,
245                                             uint_least32_t  actual,
246                                             const char     *expression_expected,
247                                             const char     *expression_actual);
248 void        cut_assert_not_equal_uint_least32_helper
249                                            (uint_least32_t  expected,
250                                             uint_least32_t  actual,
251                                             const char     *expression_expected,
252                                             const char     *expression_actual);
253 void        cut_assert_equal_uint_least64_helper
254                                            (uint_least64_t  expected,
255                                             uint_least64_t  actual,
256                                             const char     *expression_expected,
257                                             const char     *expression_actual);
258 void        cut_assert_not_equal_uint_least64_helper
259                                            (uint_least64_t  expected,
260                                             uint_least64_t  actual,
261                                             const char     *expression_expected,
262                                             const char     *expression_actual);
263 void        cut_assert_equal_uint_fast8_helper
264                                            (uint_fast8_t    expected,
265                                             uint_fast8_t    actual,
266                                             const char     *expression_expected,
267                                             const char     *expression_actual);
268 void        cut_assert_not_equal_uint_fast8_helper
269                                            (uint_fast8_t    expected,
270                                             uint_fast8_t    actual,
271                                             const char     *expression_expected,
272                                             const char     *expression_actual);
273 void        cut_assert_equal_uint_fast16_helper
274                                            (uint_fast16_t   expected,
275                                             uint_fast16_t   actual,
276                                             const char     *expression_expected,
277                                             const char     *expression_actual);
278 void        cut_assert_not_equal_uint_fast16_helper
279                                            (uint_fast16_t   expected,
280                                             uint_fast16_t   actual,
281                                             const char     *expression_expected,
282                                             const char     *expression_actual);
283 void        cut_assert_equal_uint_fast32_helper
284                                            (uint_fast32_t   expected,
285                                             uint_fast32_t   actual,
286                                             const char     *expression_expected,
287                                             const char     *expression_actual);
288 void        cut_assert_not_equal_uint_fast32_helper
289                                            (uint_fast32_t   expected,
290                                             uint_fast32_t   actual,
291                                             const char     *expression_expected,
292                                             const char     *expression_actual);
293 void        cut_assert_equal_uint_fast64_helper
294                                            (uint_fast64_t   expected,
295                                             uint_fast64_t   actual,
296                                             const char     *expression_expected,
297                                             const char     *expression_actual);
298 void        cut_assert_not_equal_uint_fast64_helper
299                                            (uint_fast64_t   expected,
300                                             uint_fast64_t   actual,
301                                             const char     *expression_expected,
302                                             const char     *expression_actual);
303 void        cut_assert_equal_uintptr_helper(uintptr_t       expected,
304                                             uintptr_t       actual,
305                                             const char     *expression_expected,
306                                             const char     *expression_actual);
307 void        cut_assert_not_equal_uintptr_helper
308                                            (uintptr_t       expected,
309                                             uintptr_t       actual,
310                                             const char     *expression_expected,
311                                             const char     *expression_actual);
312 void        cut_assert_equal_uintmax_helper(uintmax_t       expected,
313                                             uintmax_t       actual,
314                                             const char     *expression_expected,
315                                             const char     *expression_actual);
316 void        cut_assert_not_equal_uintmax_helper
317                                            (uintmax_t       expected,
318                                             uintmax_t       actual,
319                                             const char     *expression_expected,
320                                             const char     *expression_actual);
321 #endif
322 void        cut_assert_equal_size_helper   (size_t          expected,
323                                             size_t          actual,
324                                             const char     *expression_expected,
325                                             const char     *expression_actual);
326 void        cut_assert_not_equal_size_helper
327                                            (size_t          expected,
328                                             size_t          actual,
329                                             const char     *expression_expected,
330                                             const char     *expression_actual);
331 void        cut_assert_equal_double_helper (double          expected,
332                                             double          error,
333                                             double          actual,
334                                             const char     *expression_expected,
335                                             const char     *expression_error,
336                                             const char     *expression_actual);
337 void        cut_assert_not_equal_double_helper
338                                            (double          expected,
339                                             double          error,
340                                             double          actual,
341                                             const char     *expression_expected,
342                                             const char     *expression_error,
343                                             const char     *expression_actual);
344 void        cut_assert_equal_char_helper   (char            expected,
345                                             char            actual,
346                                             const char     *expression_expected,
347                                             const char     *expression_actual);
348 void        cut_assert_not_equal_char_helper
349                                            (char            expected,
350                                             char            actual,
351                                             const char     *expression_expected,
352                                             const char     *expression_actual);
353 void        cut_assert_equal_string_helper (const char     *expected,
354                                             const char     *actual,
355                                             const char     *expression_expected,
356                                             const char     *expression_actual);
357 void        cut_assert_not_equal_string_helper
358                                            (const char     *expected,
359                                             const char     *actual,
360                                             const char     *expression_expected,
361                                             const char     *expression_actual);
362 void        cut_assert_equal_substring_helper
363                                            (const char     *expected,
364                                             const char     *actual,
365                                             size_t          length,
366                                             const char     *expression_expected,
367                                             const char     *expression_actual,
368                                             const char     *expression_length);
369 void        cut_assert_not_equal_substring_helper
370                                            (const char     *expected,
371                                             const char     *actual,
372                                             size_t          length,
373                                             const char     *expression_expected,
374                                             const char     *expression_actual,
375                                             const char     *expression_length);
376 void        cut_assert_equal_memory_helper (const void     *expected,
377                                             size_t          expected_size,
378                                             const void     *actual,
379                                             size_t          actual_size,
380                                             const char     *expression_expected,
381                                             const char     *expression_expected_size,
382                                             const char     *expression_actual,
383                                             const char     *expression_actual_size);
384 void        cut_assert_not_equal_memory_helper
385                                            (const void     *expected,
386                                             size_t          expected_size,
387                                             const void     *actual,
388                                             size_t          actual_size,
389                                             const char     *expression_expected,
390                                             const char     *expression_expected_size,
391                                             const char     *expression_actual,
392                                             const char     *expression_actual_size);
393 void        cut_assert_equal_string_array_helper
394                                            (char          **expected,
395                                             char          **actual,
396                                             const char     *expression_expected,
397                                             const char     *expression_actual);
398 void        cut_assert_operator_helper     (cut_boolean     result,
399                                             const char     *expression_lhs,
400                                             const char     *expression_operator,
401                                             const char     *expression_rhs);
402 void        cut_assert_operator_int_helper (cut_boolean     result,
403                                             long            lhs,
404                                             long            rhs,
405                                             const char     *expression_lhs,
406                                             const char     *expression_operator,
407                                             const char     *expression_rhs);
408 void        cut_assert_operator_uint_helper(cut_boolean     result,
409                                             unsigned long   lhs,
410                                             unsigned long   rhs,
411                                             const char     *expression_lhs,
412                                             const char     *expression_operator,
413                                             const char     *expression_rhs);
414 void        cut_assert_operator_size_helper(cut_boolean     result,
415                                             size_t          lhs,
416                                             size_t          rhs,
417                                             const char     *expression_lhs,
418                                             const char     *expression_operator,
419                                             const char     *expression_rhs);
420 void        cut_assert_operator_double_helper
421                                            (cut_boolean     result,
422                                             double          lhs,
423                                             double          rhs,
424                                             const char     *expression_lhs,
425                                             const char     *expression_operator,
426                                             const char     *expression_rhs);
427 void        cut_assert_equal_helper (cut_boolean     result,
428                                      const char     *expression_function,
429                                      const char     *expression_expected,
430                                      const char     *expression_actual);
431 void        cut_assert_errno_helper (void);
432 void        cut_assert_exist_path_helper
433                                     (const char     *path,
434                                      const char     *expression_path);
435 void        cut_assert_not_exist_path_helper
436                                     (const char     *path,
437                                      const char     *expression_path);
438 void        cut_assert_match_helper (const char     *pattern,
439                                      const char     *actual,
440                                      const char     *expression_pattern,
441                                      const char     *expression_actual);
442 void        cut_assert_equal_pointer_helper
443                                     (const void     *expected,
444                                      const void     *actual,
445                                      const char     *expression_expected,
446                                      const char     *expression_actual);
447 void        cut_assert_equal_fixture_data_string_helper
448                                     (const char     *expected,
449                                      const char     *expression_expected,
450                                      const char     *path,
451                                      ...) CUT_GNUC_NULL_TERMINATED;
452 void        cut_assert_equal_file_raw_helper
453                                     (const char     *expected,
454                                      const char     *actual,
455                                      const char     *expression_expected,
456                                      const char     *expression_actual);
457 void        cut_assert_not_equal_file_raw_helper
458                                     (const char     *expected,
459                                      const char     *actual,
460                                      const char     *expression_expected,
461                                      const char     *expression_actual);
462 #ifndef CUT_DISABLE_SOCKET_SUPPORT
463 void        cut_assert_equal_sockaddr_helper
464                                     (const struct sockaddr *expected,
465                                      const struct sockaddr *actual,
466                                      const char     *expression_expected,
467                                      const char     *expression_actual);
468 #endif
469 void        cut_error_errno_helper  (void);
470 
471 #ifdef __cplusplus
472 }
473 #endif
474 
475 #endif /* __CUT_ASSERTIONS_HELPER_H__ */
476 
477 /*
478 vi:nowrap:ai:expandtab:sw=4
479 */
480