1 /* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * Copyright (C) 2008-2011 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 #ifdef HAVE_CONFIG_H
21 # include <config.h>
22 #endif /* HAVE_CONFIG_H */
23
24 #include <string.h>
25 #include <errno.h>
26 #ifdef HAVE_UNISTD_H
27 # include <unistd.h>
28 #endif
29
30 #include <glib.h>
31 #include <glib/gstdio.h>
32
33 #if defined(HAVE_STDINT_H) && !defined(HAVE_INTTYPES_H)
34 # if !defined(G_GINTPTR_MODIFIER)
35 # if GLIB_SIZEOF_VOID_P == 8
36 # define G_GINTPTR_MODIFIER "l"
37 # define G_GINTPTR_FORMAT "li"
38 # define G_GUINTPTR_FORMAT "lu"
39 # else
40 # define G_GINTPTR_MODIFIER ""
41 # define G_GINTPTR_FORMAT "i"
42 # define G_GUINTPTR_FORMAT "u"
43 # endif
44 # endif
45
46 # define PRIdLEAST8 "d"
47 # define PRIdLEAST16 "d"
48 # define PRIdLEAST32 G_GINT32_FORMAT
49 # define PRIdLEAST64 G_GINT64_FORMAT
50 # define PRIdFAST8 "d"
51 # define PRIdFAST16 G_GINTPTR_MODIFIER "d"
52 # define PRIdFAST32 G_GINTPTR_MODIFIER "d"
53 # define PRIdFAST64 G_GINT64_FORMAT
54 # define PRIdMAX G_GINT64_FORMAT
55 # define PRIdPTR G_GINTPTR_FORMAT
56 # define PRIuLEAST8 "u"
57 # define PRIuLEAST16 "u"
58 # define PRIuLEAST32 G_GUINT32_FORMAT
59 # define PRIuLEAST64 G_GUINT64_FORMAT
60 # define PRIuFAST8 "u"
61 # define PRIuFAST16 G_GINTPTR_MODIFIER "u"
62 # define PRIuFAST32 G_GINTPTR_MODIFIER "u"
63 # define PRIuFAST64 G_GUINT64_FORMAT
64 # define PRIuMAX G_GUINT64_FORMAT
65 # define PRIuPTR G_GUINTPTR_FORMAT
66 #endif
67
68 #include <errno.h>
69
70 #include "cut-helper.h"
71 #include <gcutter/gcut-assertions-helper.h>
72
73 void
cut_assert_helper(cut_boolean result,const char * expression)74 cut_assert_helper (cut_boolean result,
75 const char *expression)
76 {
77 if (result) {
78 cut_test_pass();
79 } else {
80 cut_test_fail(cut_take_printf("expected: <%s> is neither FALSE nor NULL",
81 expression));
82 }
83 }
84
85 void
cut_assert_true_helper(cut_boolean result,const char * expression)86 cut_assert_true_helper (cut_boolean result,
87 const char *expression)
88 {
89 if (result) {
90 cut_test_pass();
91 } else {
92 cut_test_fail(cut_take_printf("expected: <%s> is TRUE value",
93 expression));
94 }
95 }
96
97 void
cut_assert_false_helper(cut_boolean result,const char * expression)98 cut_assert_false_helper (cut_boolean result,
99 const char *expression)
100 {
101 if (result) {
102 cut_test_fail(cut_take_printf("expected: <%s> is FALSE/NULL",
103 expression));
104 } else {
105 cut_test_pass();
106 }
107 }
108
109 void
cut_assert_equal_boolean_helper(cut_boolean expected,cut_boolean actual,const char * expression_expected,const char * expression_actual)110 cut_assert_equal_boolean_helper (cut_boolean expected,
111 cut_boolean actual,
112 const char *expression_expected,
113 const char *expression_actual)
114 {
115 if ((expected && actual) || (!expected && !actual)) {
116 cut_test_pass();
117 } else {
118 cut_set_expected(expected ? "true" : "false");
119 cut_set_actual(actual ? "true" : "false");
120 cut_test_fail(cut_take_printf("<%s == %s>",
121 expression_expected,
122 expression_actual));
123 }
124 }
125
126 void
cut_assert_not_equal_boolean_helper(cut_boolean expected,cut_boolean actual,const char * expression_expected,const char * expression_actual)127 cut_assert_not_equal_boolean_helper (cut_boolean expected,
128 cut_boolean actual,
129 const char *expression_expected,
130 const char *expression_actual)
131 {
132 if ((expected && actual) || (!expected && !actual)) {
133 cut_set_expected(expected ? "true" : "false");
134 cut_set_actual(actual ? "true" : "false");
135 cut_test_fail(cut_take_printf("<%s != %s>",
136 expression_expected,
137 expression_actual));
138 } else {
139 cut_test_pass();
140 }
141 }
142
143 void
cut_assert_null_helper(const void * object,const char * expression)144 cut_assert_null_helper (const void *object,
145 const char *expression)
146 {
147 if (object == NULL) {
148 cut_test_pass();
149 } else {
150 cut_test_fail(cut_take_printf("expected: <%s> is NULL",
151 expression));
152 }
153 }
154
155 void
cut_assert_null_string_helper(const char * string,const char * expression)156 cut_assert_null_string_helper (const char *string,
157 const char *expression)
158 {
159 if (string == NULL) {
160 cut_test_pass();
161 } else {
162 cut_set_expected("<NULL>");
163 cut_set_actual(string);
164 cut_test_fail(cut_take_printf("<%s> is NULL", expression));
165 }
166 }
167
168 void
cut_assert_not_null_helper(const void * object,const char * expression)169 cut_assert_not_null_helper (const void *object,
170 const char *expression)
171 {
172 if (object != NULL) {
173 cut_test_pass();
174 } else {
175 cut_test_fail(cut_take_printf("expected: <%s> is not NULL",
176 expression));
177 }
178 }
179
180 void
cut_assert_equal_int_helper(long expected,long actual,const char * expression_expected,const char * expression_actual)181 cut_assert_equal_int_helper (long expected,
182 long actual,
183 const char *expression_expected,
184 const char *expression_actual)
185 {
186 if (expected == actual) {
187 cut_test_pass();
188 } else {
189 cut_set_expected(cut_take_printf("%ld", expected));
190 cut_set_actual(cut_take_printf("%ld", actual));
191 cut_test_fail(cut_take_printf("<%s == %s>",
192 expression_expected,
193 expression_actual));
194 }
195 }
196
197 void
cut_assert_not_equal_int_helper(long expected,long actual,const char * expression_expected,const char * expression_actual)198 cut_assert_not_equal_int_helper (long expected,
199 long actual,
200 const char *expression_expected,
201 const char *expression_actual)
202 {
203 if (expected != actual) {
204 cut_test_pass();
205 } else {
206 cut_set_expected(cut_take_printf("%ld", expected));
207 cut_set_actual(cut_take_printf("%ld", actual));
208 cut_test_fail(cut_take_printf("<%s != %s>",
209 expression_expected,
210 expression_actual));
211 }
212 }
213
214 #ifdef CUT_SUPPORT_C99_STDINT_TYPES
215 void
cut_assert_equal_int_least8_helper(int_least8_t expected,int_least8_t actual,const char * expression_expected,const char * expression_actual)216 cut_assert_equal_int_least8_helper (int_least8_t expected,
217 int_least8_t actual,
218 const char *expression_expected,
219 const char *expression_actual)
220 {
221 if (expected == actual) {
222 cut_test_pass();
223 } else {
224 cut_set_expected(cut_take_printf("%" PRIdLEAST8, expected));
225 cut_set_actual(cut_take_printf("%" PRIdLEAST8, actual));
226 cut_test_fail(cut_take_printf("<%s == %s>",
227 expression_expected,
228 expression_actual));
229 }
230 }
231
232 void
cut_assert_not_equal_int_least8_helper(int_least8_t expected,int_least8_t actual,const char * expression_expected,const char * expression_actual)233 cut_assert_not_equal_int_least8_helper (int_least8_t expected,
234 int_least8_t actual,
235 const char *expression_expected,
236 const char *expression_actual)
237 {
238 if (expected != actual) {
239 cut_test_pass();
240 } else {
241 cut_set_expected(cut_take_printf("%" PRIdLEAST8, expected));
242 cut_set_actual(cut_take_printf("%" PRIdLEAST8, actual));
243 cut_test_fail(cut_take_printf("<%s != %s>",
244 expression_expected,
245 expression_actual));
246 }
247 }
248
249 void
cut_assert_equal_int_least16_helper(int_least16_t expected,int_least16_t actual,const char * expression_expected,const char * expression_actual)250 cut_assert_equal_int_least16_helper (int_least16_t expected,
251 int_least16_t actual,
252 const char *expression_expected,
253 const char *expression_actual)
254 {
255 if (expected == actual) {
256 cut_test_pass();
257 } else {
258 cut_set_expected(cut_take_printf("%" PRIdLEAST16, expected));
259 cut_set_actual(cut_take_printf("%" PRIdLEAST16, actual));
260 cut_test_fail(cut_take_printf("<%s == %s>",
261 expression_expected,
262 expression_actual));
263 }
264 }
265
266 void
cut_assert_not_equal_int_least16_helper(int_least16_t expected,int_least16_t actual,const char * expression_expected,const char * expression_actual)267 cut_assert_not_equal_int_least16_helper (int_least16_t expected,
268 int_least16_t actual,
269 const char *expression_expected,
270 const char *expression_actual)
271 {
272 if (expected != actual) {
273 cut_test_pass();
274 } else {
275 cut_set_expected(cut_take_printf("%" PRIdLEAST16, expected));
276 cut_set_actual(cut_take_printf("%" PRIdLEAST16, actual));
277 cut_test_fail(cut_take_printf("<%s != %s>",
278 expression_expected,
279 expression_actual));
280 }
281 }
282
283 void
cut_assert_equal_int_least32_helper(int_least32_t expected,int_least32_t actual,const char * expression_expected,const char * expression_actual)284 cut_assert_equal_int_least32_helper (int_least32_t expected,
285 int_least32_t actual,
286 const char *expression_expected,
287 const char *expression_actual)
288 {
289 if (expected == actual) {
290 cut_test_pass();
291 } else {
292 cut_set_expected(cut_take_printf("%" PRIdLEAST32, expected));
293 cut_set_actual(cut_take_printf("%" PRIdLEAST32, actual));
294 cut_test_fail(cut_take_printf("<%s == %s>",
295 expression_expected,
296 expression_actual));
297 }
298 }
299
300 void
cut_assert_not_equal_int_least32_helper(int_least32_t expected,int_least32_t actual,const char * expression_expected,const char * expression_actual)301 cut_assert_not_equal_int_least32_helper (int_least32_t expected,
302 int_least32_t actual,
303 const char *expression_expected,
304 const char *expression_actual)
305 {
306 if (expected != actual) {
307 cut_test_pass();
308 } else {
309 cut_set_expected(cut_take_printf("%" PRIdLEAST32, expected));
310 cut_set_actual(cut_take_printf("%" PRIdLEAST32, actual));
311 cut_test_fail(cut_take_printf("<%s != %s>",
312 expression_expected,
313 expression_actual));
314 }
315 }
316
317 void
cut_assert_equal_int_least64_helper(int_least64_t expected,int_least64_t actual,const char * expression_expected,const char * expression_actual)318 cut_assert_equal_int_least64_helper (int_least64_t expected,
319 int_least64_t actual,
320 const char *expression_expected,
321 const char *expression_actual)
322 {
323 if (expected == actual) {
324 cut_test_pass();
325 } else {
326 cut_set_expected(cut_take_printf("%" PRIdLEAST64, expected));
327 cut_set_actual(cut_take_printf("%" PRIdLEAST64, actual));
328 cut_test_fail(cut_take_printf("<%s == %s>",
329 expression_expected,
330 expression_actual));
331 }
332 }
333
334 void
cut_assert_not_equal_int_least64_helper(int_least64_t expected,int_least64_t actual,const char * expression_expected,const char * expression_actual)335 cut_assert_not_equal_int_least64_helper (int_least64_t expected,
336 int_least64_t actual,
337 const char *expression_expected,
338 const char *expression_actual)
339 {
340 if (expected != actual) {
341 cut_test_pass();
342 } else {
343 cut_set_expected(cut_take_printf("%" PRIdLEAST64, expected));
344 cut_set_actual(cut_take_printf("%" PRIdLEAST64, actual));
345 cut_test_fail(cut_take_printf("<%s != %s>",
346 expression_expected,
347 expression_actual));
348 }
349 }
350
351 void
cut_assert_equal_int_fast8_helper(int_fast8_t expected,int_fast8_t actual,const char * expression_expected,const char * expression_actual)352 cut_assert_equal_int_fast8_helper (int_fast8_t expected,
353 int_fast8_t actual,
354 const char *expression_expected,
355 const char *expression_actual)
356 {
357 if (expected == actual) {
358 cut_test_pass();
359 } else {
360 cut_set_expected(cut_take_printf("%" PRIdFAST8, expected));
361 cut_set_actual(cut_take_printf("%" PRIdFAST8, actual));
362 cut_test_fail(cut_take_printf("<%s == %s>",
363 expression_expected,
364 expression_actual));
365 }
366 }
367
368 void
cut_assert_not_equal_int_fast8_helper(int_fast8_t expected,int_fast8_t actual,const char * expression_expected,const char * expression_actual)369 cut_assert_not_equal_int_fast8_helper (int_fast8_t expected,
370 int_fast8_t actual,
371 const char *expression_expected,
372 const char *expression_actual)
373 {
374 if (expected != actual) {
375 cut_test_pass();
376 } else {
377 cut_set_expected(cut_take_printf("%" PRIdFAST8, expected));
378 cut_set_actual(cut_take_printf("%" PRIdFAST8, actual));
379 cut_test_fail(cut_take_printf("<%s != %s>",
380 expression_expected,
381 expression_actual));
382 }
383 }
384
385 void
cut_assert_equal_int_fast16_helper(int_fast16_t expected,int_fast16_t actual,const char * expression_expected,const char * expression_actual)386 cut_assert_equal_int_fast16_helper (int_fast16_t expected,
387 int_fast16_t actual,
388 const char *expression_expected,
389 const char *expression_actual)
390 {
391 if (expected == actual) {
392 cut_test_pass();
393 } else {
394 cut_set_expected(cut_take_printf("%" PRIdFAST16, expected));
395 cut_set_actual(cut_take_printf("%" PRIdFAST16, actual));
396 cut_test_fail(cut_take_printf("<%s == %s>",
397 expression_expected,
398 expression_actual));
399 }
400 }
401
402 void
cut_assert_not_equal_int_fast16_helper(int_fast16_t expected,int_fast16_t actual,const char * expression_expected,const char * expression_actual)403 cut_assert_not_equal_int_fast16_helper (int_fast16_t expected,
404 int_fast16_t actual,
405 const char *expression_expected,
406 const char *expression_actual)
407 {
408 if (expected != actual) {
409 cut_test_pass();
410 } else {
411 cut_set_expected(cut_take_printf("%" PRIdFAST16, expected));
412 cut_set_actual(cut_take_printf("%" PRIdFAST16, actual));
413 cut_test_fail(cut_take_printf("<%s != %s>",
414 expression_expected,
415 expression_actual));
416 }
417 }
418
419 void
cut_assert_equal_int_fast32_helper(int_fast32_t expected,int_fast32_t actual,const char * expression_expected,const char * expression_actual)420 cut_assert_equal_int_fast32_helper (int_fast32_t expected,
421 int_fast32_t actual,
422 const char *expression_expected,
423 const char *expression_actual)
424 {
425 if (expected == actual) {
426 cut_test_pass();
427 } else {
428 cut_set_expected(cut_take_printf("%" PRIdFAST32, expected));
429 cut_set_actual(cut_take_printf("%" PRIdFAST32, actual));
430 cut_test_fail(cut_take_printf("<%s == %s>",
431 expression_expected,
432 expression_actual));
433 }
434 }
435
436 void
cut_assert_not_equal_int_fast32_helper(int_fast32_t expected,int_fast32_t actual,const char * expression_expected,const char * expression_actual)437 cut_assert_not_equal_int_fast32_helper (int_fast32_t expected,
438 int_fast32_t actual,
439 const char *expression_expected,
440 const char *expression_actual)
441 {
442 if (expected != actual) {
443 cut_test_pass();
444 } else {
445 cut_set_expected(cut_take_printf("%" PRIdFAST32, expected));
446 cut_set_actual(cut_take_printf("%" PRIdFAST32, actual));
447 cut_test_fail(cut_take_printf("<%s != %s>",
448 expression_expected,
449 expression_actual));
450 }
451 }
452
453 void
cut_assert_equal_int_fast64_helper(int_fast64_t expected,int_fast64_t actual,const char * expression_expected,const char * expression_actual)454 cut_assert_equal_int_fast64_helper (int_fast64_t expected,
455 int_fast64_t actual,
456 const char *expression_expected,
457 const char *expression_actual)
458 {
459 if (expected == actual) {
460 cut_test_pass();
461 } else {
462 cut_set_expected(cut_take_printf("%" PRIdFAST64, expected));
463 cut_set_actual(cut_take_printf("%" PRIdFAST64, actual));
464 cut_test_fail(cut_take_printf("<%s == %s>",
465 expression_expected,
466 expression_actual));
467 }
468 }
469
470 void
cut_assert_not_equal_int_fast64_helper(int_fast64_t expected,int_fast64_t actual,const char * expression_expected,const char * expression_actual)471 cut_assert_not_equal_int_fast64_helper (int_fast64_t expected,
472 int_fast64_t actual,
473 const char *expression_expected,
474 const char *expression_actual)
475 {
476 if (expected != actual) {
477 cut_test_pass();
478 } else {
479 cut_set_expected(cut_take_printf("%" PRIdFAST64, expected));
480 cut_set_actual(cut_take_printf("%" PRIdFAST64, actual));
481 cut_test_fail(cut_take_printf("<%s != %s>",
482 expression_expected,
483 expression_actual));
484 }
485 }
486
487 void
cut_assert_equal_intptr_helper(intptr_t expected,intptr_t actual,const char * expression_expected,const char * expression_actual)488 cut_assert_equal_intptr_helper (intptr_t expected,
489 intptr_t actual,
490 const char *expression_expected,
491 const char *expression_actual)
492 {
493 if (expected == actual) {
494 cut_test_pass();
495 } else {
496 cut_set_expected(cut_take_printf("%" PRIdPTR, expected));
497 cut_set_actual(cut_take_printf("%" PRIdPTR, actual));
498 cut_test_fail(cut_take_printf("<%s == %s>",
499 expression_expected,
500 expression_actual));
501 }
502 }
503
504 void
cut_assert_not_equal_intptr_helper(intptr_t expected,intptr_t actual,const char * expression_expected,const char * expression_actual)505 cut_assert_not_equal_intptr_helper (intptr_t expected,
506 intptr_t actual,
507 const char *expression_expected,
508 const char *expression_actual)
509 {
510 if (expected != actual) {
511 cut_test_pass();
512 } else {
513 cut_set_expected(cut_take_printf("%" PRIdPTR, expected));
514 cut_set_actual(cut_take_printf("%" PRIdPTR, actual));
515 cut_test_fail(cut_take_printf("<%s != %s>",
516 expression_expected,
517 expression_actual));
518 }
519 }
520
521 void
cut_assert_equal_intmax_helper(intmax_t expected,intmax_t actual,const char * expression_expected,const char * expression_actual)522 cut_assert_equal_intmax_helper (intmax_t expected,
523 intmax_t actual,
524 const char *expression_expected,
525 const char *expression_actual)
526 {
527 if (expected == actual) {
528 cut_test_pass();
529 } else {
530 cut_set_expected(cut_take_printf("%" PRIdMAX, expected));
531 cut_set_actual(cut_take_printf("%" PRIdMAX, actual));
532 cut_test_fail(cut_take_printf("<%s == %s>",
533 expression_expected,
534 expression_actual));
535 }
536 }
537
538 void
cut_assert_not_equal_intmax_helper(intmax_t expected,intmax_t actual,const char * expression_expected,const char * expression_actual)539 cut_assert_not_equal_intmax_helper (intmax_t expected,
540 intmax_t actual,
541 const char *expression_expected,
542 const char *expression_actual)
543 {
544 if (expected != actual) {
545 cut_test_pass();
546 } else {
547 cut_set_expected(cut_take_printf("%" PRIdMAX, expected));
548 cut_set_actual(cut_take_printf("%" PRIdMAX, actual));
549 cut_test_fail(cut_take_printf("<%s != %s>",
550 expression_expected,
551 expression_actual));
552 }
553 }
554
555 #endif
556
557 void
cut_assert_equal_uint_helper(unsigned long expected,unsigned long actual,const char * expression_expected,const char * expression_actual)558 cut_assert_equal_uint_helper (unsigned long expected,
559 unsigned long actual,
560 const char *expression_expected,
561 const char *expression_actual)
562 {
563 if (expected == actual) {
564 cut_test_pass();
565 } else {
566 cut_set_expected(cut_take_printf("%lu", expected));
567 cut_set_actual(cut_take_printf("%lu", actual));
568 cut_test_fail(cut_take_printf("<%s == %s>",
569 expression_expected,
570 expression_actual));
571 }
572 }
573
574 void
cut_assert_not_equal_uint_helper(unsigned long expected,unsigned long actual,const char * expression_expected,const char * expression_actual)575 cut_assert_not_equal_uint_helper (unsigned long expected,
576 unsigned long actual,
577 const char *expression_expected,
578 const char *expression_actual)
579 {
580 if (expected != actual) {
581 cut_test_pass();
582 } else {
583 cut_set_expected(cut_take_printf("%lu", expected));
584 cut_set_actual(cut_take_printf("%lu", actual));
585 cut_test_fail(cut_take_printf("<%s != %s>",
586 expression_expected,
587 expression_actual));
588 }
589 }
590
591 #ifdef CUT_SUPPORT_C99_STDINT_TYPES
592
593 void
cut_assert_equal_uint_least8_helper(uint_least8_t expected,uint_least8_t actual,const char * expression_expected,const char * expression_actual)594 cut_assert_equal_uint_least8_helper (uint_least8_t expected,
595 uint_least8_t actual,
596 const char *expression_expected,
597 const char *expression_actual)
598 {
599 if (expected == actual) {
600 cut_test_pass();
601 } else {
602 cut_set_expected(cut_take_printf("%" PRIuLEAST8, expected));
603 cut_set_actual(cut_take_printf("%" PRIuLEAST8, actual));
604 cut_test_fail(cut_take_printf("<%s == %s>",
605 expression_expected,
606 expression_actual));
607 }
608 }
609
610 void
cut_assert_not_equal_uint_least8_helper(uint_least8_t expected,uint_least8_t actual,const char * expression_expected,const char * expression_actual)611 cut_assert_not_equal_uint_least8_helper (uint_least8_t expected,
612 uint_least8_t actual,
613 const char *expression_expected,
614 const char *expression_actual)
615 {
616 if (expected != actual) {
617 cut_test_pass();
618 } else {
619 cut_set_expected(cut_take_printf("%" PRIuLEAST8, expected));
620 cut_set_actual(cut_take_printf("%" PRIuLEAST8, actual));
621 cut_test_fail(cut_take_printf("<%s != %s>",
622 expression_expected,
623 expression_actual));
624 }
625 }
626
627 void
cut_assert_equal_uint_least16_helper(uint_least16_t expected,uint_least16_t actual,const char * expression_expected,const char * expression_actual)628 cut_assert_equal_uint_least16_helper (uint_least16_t expected,
629 uint_least16_t actual,
630 const char *expression_expected,
631 const char *expression_actual)
632 {
633 if (expected == actual) {
634 cut_test_pass();
635 } else {
636 cut_set_expected(cut_take_printf("%" PRIuLEAST16, expected));
637 cut_set_actual(cut_take_printf("%" PRIuLEAST16, actual));
638 cut_test_fail(cut_take_printf("<%s == %s>",
639 expression_expected,
640 expression_actual));
641 }
642 }
643
644 void
cut_assert_not_equal_uint_least16_helper(uint_least16_t expected,uint_least16_t actual,const char * expression_expected,const char * expression_actual)645 cut_assert_not_equal_uint_least16_helper (uint_least16_t expected,
646 uint_least16_t actual,
647 const char *expression_expected,
648 const char *expression_actual)
649 {
650 if (expected != actual) {
651 cut_test_pass();
652 } else {
653 cut_set_expected(cut_take_printf("%" PRIuLEAST16, expected));
654 cut_set_actual(cut_take_printf("%" PRIuLEAST16, actual));
655 cut_test_fail(cut_take_printf("<%s != %s>",
656 expression_expected,
657 expression_actual));
658 }
659 }
660
661 void
cut_assert_equal_uint_least32_helper(uint_least32_t expected,uint_least32_t actual,const char * expression_expected,const char * expression_actual)662 cut_assert_equal_uint_least32_helper (uint_least32_t expected,
663 uint_least32_t actual,
664 const char *expression_expected,
665 const char *expression_actual)
666 {
667 if (expected == actual) {
668 cut_test_pass();
669 } else {
670 cut_set_expected(cut_take_printf("%" PRIuLEAST32, expected));
671 cut_set_actual(cut_take_printf("%" PRIuLEAST32, actual));
672 cut_test_fail(cut_take_printf("<%s == %s>",
673 expression_expected,
674 expression_actual));
675 }
676 }
677
678 void
cut_assert_not_equal_uint_least32_helper(uint_least32_t expected,uint_least32_t actual,const char * expression_expected,const char * expression_actual)679 cut_assert_not_equal_uint_least32_helper (uint_least32_t expected,
680 uint_least32_t actual,
681 const char *expression_expected,
682 const char *expression_actual)
683 {
684 if (expected != actual) {
685 cut_test_pass();
686 } else {
687 cut_set_expected(cut_take_printf("%" PRIuLEAST32, expected));
688 cut_set_actual(cut_take_printf("%" PRIuLEAST32, actual));
689 cut_test_fail(cut_take_printf("<%s != %s>",
690 expression_expected,
691 expression_actual));
692 }
693 }
694
695 void
cut_assert_equal_uint_least64_helper(uint_least64_t expected,uint_least64_t actual,const char * expression_expected,const char * expression_actual)696 cut_assert_equal_uint_least64_helper (uint_least64_t expected,
697 uint_least64_t actual,
698 const char *expression_expected,
699 const char *expression_actual)
700 {
701 if (expected == actual) {
702 cut_test_pass();
703 } else {
704 cut_set_expected(cut_take_printf("%" PRIuLEAST64, expected));
705 cut_set_actual(cut_take_printf("%" PRIuLEAST64, actual));
706 cut_test_fail(cut_take_printf("<%s == %s>",
707 expression_expected,
708 expression_actual));
709 }
710 }
711
712 void
cut_assert_not_equal_uint_least64_helper(uint_least64_t expected,uint_least64_t actual,const char * expression_expected,const char * expression_actual)713 cut_assert_not_equal_uint_least64_helper (uint_least64_t expected,
714 uint_least64_t actual,
715 const char *expression_expected,
716 const char *expression_actual)
717 {
718 if (expected != actual) {
719 cut_test_pass();
720 } else {
721 cut_set_expected(cut_take_printf("%" PRIuLEAST64, expected));
722 cut_set_actual(cut_take_printf("%" PRIuLEAST64, actual));
723 cut_test_fail(cut_take_printf("<%s != %s>",
724 expression_expected,
725 expression_actual));
726 }
727 }
728
729 void
cut_assert_equal_uint_fast8_helper(uint_fast8_t expected,uint_fast8_t actual,const char * expression_expected,const char * expression_actual)730 cut_assert_equal_uint_fast8_helper (uint_fast8_t expected,
731 uint_fast8_t actual,
732 const char *expression_expected,
733 const char *expression_actual)
734 {
735 if (expected == actual) {
736 cut_test_pass();
737 } else {
738 cut_set_expected(cut_take_printf("%" PRIuFAST8, expected));
739 cut_set_actual(cut_take_printf("%" PRIuFAST8, actual));
740 cut_test_fail(cut_take_printf("<%s == %s>",
741 expression_expected,
742 expression_actual));
743 }
744 }
745
746 void
cut_assert_not_equal_uint_fast8_helper(uint_fast8_t expected,uint_fast8_t actual,const char * expression_expected,const char * expression_actual)747 cut_assert_not_equal_uint_fast8_helper (uint_fast8_t expected,
748 uint_fast8_t actual,
749 const char *expression_expected,
750 const char *expression_actual)
751 {
752 if (expected != actual) {
753 cut_test_pass();
754 } else {
755 cut_set_expected(cut_take_printf("%" PRIuFAST8, expected));
756 cut_set_actual(cut_take_printf("%" PRIuFAST8, actual));
757 cut_test_fail(cut_take_printf("<%s != %s>",
758 expression_expected,
759 expression_actual));
760 }
761 }
762
763 void
cut_assert_equal_uint_fast16_helper(uint_fast16_t expected,uint_fast16_t actual,const char * expression_expected,const char * expression_actual)764 cut_assert_equal_uint_fast16_helper (uint_fast16_t expected,
765 uint_fast16_t actual,
766 const char *expression_expected,
767 const char *expression_actual)
768 {
769 if (expected == actual) {
770 cut_test_pass();
771 } else {
772 cut_set_expected(cut_take_printf("%" PRIuFAST16, expected));
773 cut_set_actual(cut_take_printf("%" PRIuFAST16, actual));
774 cut_test_fail(cut_take_printf("<%s == %s>",
775 expression_expected,
776 expression_actual));
777 }
778 }
779
780 void
cut_assert_not_equal_uint_fast16_helper(uint_fast16_t expected,uint_fast16_t actual,const char * expression_expected,const char * expression_actual)781 cut_assert_not_equal_uint_fast16_helper (uint_fast16_t expected,
782 uint_fast16_t actual,
783 const char *expression_expected,
784 const char *expression_actual)
785 {
786 if (expected != actual) {
787 cut_test_pass();
788 } else {
789 cut_set_expected(cut_take_printf("%" PRIuFAST16, expected));
790 cut_set_actual(cut_take_printf("%" PRIuFAST16, actual));
791 cut_test_fail(cut_take_printf("<%s != %s>",
792 expression_expected,
793 expression_actual));
794 }
795 }
796
797 void
cut_assert_equal_uint_fast32_helper(uint_fast32_t expected,uint_fast32_t actual,const char * expression_expected,const char * expression_actual)798 cut_assert_equal_uint_fast32_helper (uint_fast32_t expected,
799 uint_fast32_t actual,
800 const char *expression_expected,
801 const char *expression_actual)
802 {
803 if (expected == actual) {
804 cut_test_pass();
805 } else {
806 cut_set_expected(cut_take_printf("%" PRIuFAST32, expected));
807 cut_set_actual(cut_take_printf("%" PRIuFAST32, actual));
808 cut_test_fail(cut_take_printf("<%s == %s>",
809 expression_expected,
810 expression_actual));
811 }
812 }
813
814 void
cut_assert_not_equal_uint_fast32_helper(uint_fast32_t expected,uint_fast32_t actual,const char * expression_expected,const char * expression_actual)815 cut_assert_not_equal_uint_fast32_helper (uint_fast32_t expected,
816 uint_fast32_t actual,
817 const char *expression_expected,
818 const char *expression_actual)
819 {
820 if (expected != actual) {
821 cut_test_pass();
822 } else {
823 cut_set_expected(cut_take_printf("%" PRIuFAST32, expected));
824 cut_set_actual(cut_take_printf("%" PRIuFAST32, actual));
825 cut_test_fail(cut_take_printf("<%s != %s>",
826 expression_expected,
827 expression_actual));
828 }
829 }
830
831 void
cut_assert_equal_uint_fast64_helper(uint_fast64_t expected,uint_fast64_t actual,const char * expression_expected,const char * expression_actual)832 cut_assert_equal_uint_fast64_helper (uint_fast64_t expected,
833 uint_fast64_t actual,
834 const char *expression_expected,
835 const char *expression_actual)
836 {
837 if (expected == actual) {
838 cut_test_pass();
839 } else {
840 cut_set_expected(cut_take_printf("%" PRIuFAST64, expected));
841 cut_set_actual(cut_take_printf("%" PRIuFAST64, actual));
842 cut_test_fail(cut_take_printf("<%s == %s>",
843 expression_expected,
844 expression_actual));
845 }
846 }
847
848 void
cut_assert_not_equal_uint_fast64_helper(uint_fast64_t expected,uint_fast64_t actual,const char * expression_expected,const char * expression_actual)849 cut_assert_not_equal_uint_fast64_helper (uint_fast64_t expected,
850 uint_fast64_t actual,
851 const char *expression_expected,
852 const char *expression_actual)
853 {
854 if (expected != actual) {
855 cut_test_pass();
856 } else {
857 cut_set_expected(cut_take_printf("%" PRIuFAST64, expected));
858 cut_set_actual(cut_take_printf("%" PRIuFAST64, actual));
859 cut_test_fail(cut_take_printf("<%s != %s>",
860 expression_expected,
861 expression_actual));
862 }
863 }
864
865 void
cut_assert_equal_uintptr_helper(uintptr_t expected,uintptr_t actual,const char * expression_expected,const char * expression_actual)866 cut_assert_equal_uintptr_helper (uintptr_t expected,
867 uintptr_t actual,
868 const char *expression_expected,
869 const char *expression_actual)
870 {
871 if (expected == actual) {
872 cut_test_pass();
873 } else {
874 cut_set_expected(cut_take_printf("%" PRIuPTR, expected));
875 cut_set_actual(cut_take_printf("%" PRIuPTR, actual));
876 cut_test_fail(cut_take_printf("<%s == %s>",
877 expression_expected,
878 expression_actual));
879 }
880 }
881
882 void
cut_assert_not_equal_uintptr_helper(uintptr_t expected,uintptr_t actual,const char * expression_expected,const char * expression_actual)883 cut_assert_not_equal_uintptr_helper (uintptr_t expected,
884 uintptr_t actual,
885 const char *expression_expected,
886 const char *expression_actual)
887 {
888 if (expected != actual) {
889 cut_test_pass();
890 } else {
891 cut_set_expected(cut_take_printf("%" PRIuPTR, expected));
892 cut_set_actual(cut_take_printf("%" PRIuPTR, actual));
893 cut_test_fail(cut_take_printf("<%s != %s>",
894 expression_expected,
895 expression_actual));
896 }
897 }
898
899 void
cut_assert_equal_uintmax_helper(uintmax_t expected,uintmax_t actual,const char * expression_expected,const char * expression_actual)900 cut_assert_equal_uintmax_helper (uintmax_t expected,
901 uintmax_t actual,
902 const char *expression_expected,
903 const char *expression_actual)
904 {
905 if (expected == actual) {
906 cut_test_pass();
907 } else {
908 cut_set_expected(cut_take_printf("%" PRIuMAX, expected));
909 cut_set_actual(cut_take_printf("%" PRIuMAX, actual));
910 cut_test_fail(cut_take_printf("<%s == %s>",
911 expression_expected,
912 expression_actual));
913 }
914 }
915
916 void
cut_assert_not_equal_uintmax_helper(uintmax_t expected,uintmax_t actual,const char * expression_expected,const char * expression_actual)917 cut_assert_not_equal_uintmax_helper (uintmax_t expected,
918 uintmax_t actual,
919 const char *expression_expected,
920 const char *expression_actual)
921 {
922 if (expected != actual) {
923 cut_test_pass();
924 } else {
925 cut_set_expected(cut_take_printf("%" PRIuMAX, expected));
926 cut_set_actual(cut_take_printf("%" PRIuMAX, actual));
927 cut_test_fail(cut_take_printf("<%s != %s>",
928 expression_expected,
929 expression_actual));
930 }
931 }
932
933 #endif
934
935 void
cut_assert_equal_size_helper(size_t expected,size_t actual,const char * expression_expected,const char * expression_actual)936 cut_assert_equal_size_helper (size_t expected,
937 size_t actual,
938 const char *expression_expected,
939 const char *expression_actual)
940 {
941 if (expected == actual) {
942 cut_test_pass();
943 } else {
944 cut_set_expected(cut_take_printf("%" G_GSIZE_FORMAT, expected));
945 cut_set_actual(cut_take_printf("%" G_GSIZE_FORMAT, actual));
946 cut_test_fail(cut_take_printf("<%s == %s>",
947 expression_expected,
948 expression_actual));
949 }
950 }
951
952 void
cut_assert_not_equal_size_helper(size_t expected,size_t actual,const char * expression_expected,const char * expression_actual)953 cut_assert_not_equal_size_helper (size_t expected,
954 size_t actual,
955 const char *expression_expected,
956 const char *expression_actual)
957 {
958 if (expected != actual) {
959 cut_test_pass();
960 } else {
961 cut_set_expected(cut_take_printf("%" G_GSIZE_FORMAT, expected));
962 cut_set_actual(cut_take_printf("%" G_GSIZE_FORMAT, actual));
963 cut_test_fail(cut_take_printf("<%s != %s>",
964 expression_expected,
965 expression_actual));
966 }
967 }
968
969 void
cut_assert_equal_double_helper(double expected,double error,double actual,const char * expression_expected,const char * expression_error,const char * expression_actual)970 cut_assert_equal_double_helper (double expected,
971 double error,
972 double actual,
973 const char *expression_expected,
974 const char *expression_error,
975 const char *expression_actual)
976 {
977 if (cut_utils_equal_double(expected, actual, error)) {
978 cut_test_pass();
979 } else {
980 double min, max;
981 const gchar *relation;
982
983 if (error > 0) {
984 min = expected - error;
985 max = expected + error;
986 } else {
987 min = expected + error;
988 max = expected - error;
989 }
990
991 if (actual < min)
992 relation = "actual < min < max";
993 else
994 relation = "min < max < actual";
995
996 cut_test_fail(cut_take_printf("<%s-%s <= %s <= %s+%s>\n"
997 "expected: <%g>\n"
998 " error: <%g>\n"
999 " min: <%g>\n"
1000 " max: <%g>\n"
1001 " actual: <%g>\n"
1002 "relation: <%s>",
1003 expression_expected,
1004 expression_error,
1005 expression_actual,
1006 expression_expected,
1007 expression_error,
1008 expected,
1009 error,
1010 min,
1011 max,
1012 actual,
1013 relation));
1014 }
1015 }
1016
1017 void
cut_assert_not_equal_double_helper(double expected,double error,double actual,const char * expression_expected,const char * expression_error,const char * expression_actual)1018 cut_assert_not_equal_double_helper (double expected,
1019 double error,
1020 double actual,
1021 const char *expression_expected,
1022 const char *expression_error,
1023 const char *expression_actual)
1024 {
1025 if (!cut_utils_equal_double(expected, actual, error)) {
1026 cut_test_pass();
1027 } else {
1028 double min, max;
1029
1030 if (error > 0) {
1031 min = expected - error;
1032 max = expected + error;
1033 } else {
1034 min = expected + error;
1035 max = expected - error;
1036 }
1037
1038 cut_test_fail(cut_take_printf("<(%s < %s-%s) && (%s+%s < %s)>\n"
1039 "expected: <%g>\n"
1040 " error: <%g>\n"
1041 " min: <%g>\n"
1042 " max: <%g>\n"
1043 " actual: <%g>\n"
1044 "relation: <min < actual < max>",
1045 expression_actual,
1046 expression_expected,
1047 expression_error,
1048 expression_expected,
1049 expression_error,
1050 expression_actual,
1051 expected,
1052 error,
1053 min,
1054 max,
1055 actual));
1056 }
1057 }
1058
1059 static const gchar *
taken_inspect_char(char value)1060 taken_inspect_char (char value)
1061 {
1062 const gchar *inspected;
1063 GString *inspected_buffer;
1064
1065 inspected_buffer = g_string_new(NULL);
1066 gcut_inspect_char(inspected_buffer, &value, NULL);
1067 inspected = cut_take_strdup(inspected_buffer->str);
1068 g_string_free(inspected_buffer, TRUE);
1069
1070 return inspected;
1071 }
1072
1073 void
cut_assert_equal_char_helper(char expected,char actual,const char * expression_expected,const char * expression_actual)1074 cut_assert_equal_char_helper (char expected,
1075 char actual,
1076 const char *expression_expected,
1077 const char *expression_actual)
1078 {
1079 if (expected == actual) {
1080 cut_test_pass();
1081 } else {
1082 cut_set_expected(taken_inspect_char(expected));
1083 cut_set_actual(taken_inspect_char(actual));
1084 cut_test_fail(cut_take_printf("<%s == %s>",
1085 expression_expected,
1086 expression_actual));
1087 }
1088 }
1089
1090 void
cut_assert_not_equal_char_helper(char expected,char actual,const char * expression_expected,const char * expression_actual)1091 cut_assert_not_equal_char_helper (char expected,
1092 char actual,
1093 const char *expression_expected,
1094 const char *expression_actual)
1095 {
1096 if (expected != actual) {
1097 cut_test_pass();
1098 } else {
1099 cut_set_expected(taken_inspect_char(expected));
1100 cut_set_actual(taken_inspect_char(actual));
1101 cut_test_fail(cut_take_printf("<%s != %s>",
1102 expression_expected,
1103 expression_actual));
1104 }
1105 }
1106
1107 void
cut_assert_equal_string_helper(const char * expected,const char * actual,const char * expression_expected,const char * expression_actual)1108 cut_assert_equal_string_helper (const char *expected,
1109 const char *actual,
1110 const char *expression_expected,
1111 const char *expression_actual)
1112 {
1113 if (expected == NULL) {
1114 if (actual == NULL) {
1115 cut_test_pass();
1116 } else {
1117 cut_set_expected(cut_take_inspect_string(expected));
1118 cut_set_actual(cut_take_inspect_string(actual));
1119 cut_test_fail(cut_take_printf("<%s == NULL>",
1120 expression_actual));
1121 }
1122 } else {
1123 if (cut_utils_equal_string(expected, actual)) {
1124 cut_test_pass();
1125 } else {
1126 cut_set_expected(cut_take_inspect_string(expected));
1127 cut_set_actual(cut_take_inspect_string(actual));
1128 cut_test_fail(cut_take_printf("<%s == %s>",
1129 expression_expected,
1130 expression_actual));
1131 }
1132 }
1133 }
1134
1135 void
cut_assert_not_equal_string_helper(const char * expected,const char * actual,const char * expression_expected,const char * expression_actual)1136 cut_assert_not_equal_string_helper (const char *expected,
1137 const char *actual,
1138 const char *expression_expected,
1139 const char *expression_actual)
1140 {
1141 if (expected == NULL) {
1142 if (actual) {
1143 cut_test_pass();
1144 } else {
1145 cut_set_expected(cut_take_inspect_string(expected));
1146 cut_set_actual(cut_take_inspect_string(actual));
1147 cut_test_fail(cut_take_printf("<%s != NULL>",
1148 expression_actual));
1149 }
1150 } else {
1151 if (!cut_utils_equal_string(expected, actual)) {
1152 cut_test_pass();
1153 } else {
1154 cut_set_expected(cut_take_inspect_string(expected));
1155 cut_set_actual(cut_take_inspect_string(actual));
1156 cut_test_fail(cut_take_printf("<%s != %s>",
1157 expression_expected,
1158 expression_actual));
1159 }
1160 }
1161 }
1162
1163 void
cut_assert_equal_substring_helper(const char * expected,const char * actual,size_t length,const char * expression_expected,const char * expression_actual,const char * expression_length)1164 cut_assert_equal_substring_helper (const char *expected,
1165 const char *actual,
1166 size_t length,
1167 const char *expression_expected,
1168 const char *expression_actual,
1169 const char *expression_length)
1170 {
1171 if (expected == NULL) {
1172 if (actual == NULL) {
1173 cut_test_pass();
1174 } else {
1175 const gchar *actual_substring;
1176
1177 actual_substring = cut_take_string(g_strndup(actual, length));
1178 cut_set_expected(cut_take_inspect_string(expected));
1179 cut_set_actual(cut_take_inspect_string(actual_substring));
1180 cut_test_fail(cut_take_printf("<%s == NULL>",
1181 expression_actual));
1182 }
1183 } else {
1184 if (cut_utils_equal_substring(expected, actual, length)) {
1185 cut_test_pass();
1186 } else {
1187 const gchar *actual_substring = NULL;
1188
1189 actual_substring = cut_take_string(g_strndup(actual, length));
1190 cut_set_expected(cut_take_inspect_string(expected));
1191 cut_set_actual(cut_take_inspect_string(actual_substring));
1192 cut_test_fail(cut_take_printf("<%s == (%s)[0..%s]>",
1193 expression_expected,
1194 expression_actual,
1195 expression_length));
1196 }
1197 }
1198 }
1199
1200 void
cut_assert_not_equal_substring_helper(const char * expected,const char * actual,size_t length,const char * expression_expected,const char * expression_actual,const char * expression_length)1201 cut_assert_not_equal_substring_helper (const char *expected,
1202 const char *actual,
1203 size_t length,
1204 const char *expression_expected,
1205 const char *expression_actual,
1206 const char *expression_length)
1207 {
1208 if (expected == NULL) {
1209 if (actual) {
1210 cut_test_pass();
1211 } else {
1212 const gchar *actual_substring;
1213
1214 actual_substring = cut_take_string(g_strndup(actual, length));
1215 cut_set_expected(cut_take_inspect_string(expected));
1216 cut_set_actual(cut_take_inspect_string(actual_substring));
1217 cut_test_fail(cut_take_printf("<%s != NULL>",
1218 expression_actual));
1219 }
1220 } else {
1221 if (!cut_utils_equal_substring(expected, actual, length)) {
1222 cut_test_pass();
1223 } else {
1224 const gchar *actual_substring;
1225
1226 actual_substring = cut_take_string(g_strndup(actual, length));
1227 cut_set_expected(cut_take_inspect_string(expected));
1228 cut_set_actual(cut_take_inspect_string(actual_substring));
1229 cut_test_fail(cut_take_printf("<%s != (%s)[0..%s]>",
1230 expression_expected,
1231 expression_actual,
1232 expression_length));
1233 }
1234 }
1235 }
1236
1237 void
cut_assert_equal_memory_helper(const void * expected,size_t expected_size,const void * actual,size_t actual_size,const char * expression_expected,const char * expression_expected_size,const char * expression_actual,const char * expression_actual_size)1238 cut_assert_equal_memory_helper (const void *expected,
1239 size_t expected_size,
1240 const void *actual,
1241 size_t actual_size,
1242 const char *expression_expected,
1243 const char *expression_expected_size,
1244 const char *expression_actual,
1245 const char *expression_actual_size)
1246 {
1247 if (expected_size == actual_size &&
1248 memcmp(expected, actual, expected_size) == 0) {
1249 cut_test_pass();
1250 } else {
1251 const char *message;
1252 const char *inspected_expected;
1253 const char *inspected_actual;
1254
1255 inspected_expected =
1256 cut_take_string(cut_utils_inspect_memory(expected, expected_size));
1257 inspected_actual =
1258 cut_take_string(cut_utils_inspect_memory(actual, actual_size));
1259 message = cut_take_printf(
1260 "<%s(size: %s) == %s(size: %s)>",
1261 expression_expected,
1262 expression_expected_size,
1263 expression_actual,
1264 expression_actual_size);
1265 cut_set_expected(cut_take_printf("%s (size: %" G_GSIZE_FORMAT ")",
1266 inspected_expected,
1267 expected_size));
1268 cut_set_actual(cut_take_printf("%s (size: %" G_GSIZE_FORMAT ")",
1269 inspected_actual,
1270 actual_size));
1271 cut_test_fail(message);
1272 }
1273 }
1274
1275 void
cut_assert_not_equal_memory_helper(const void * expected,size_t expected_size,const void * actual,size_t actual_size,const char * expression_expected,const char * expression_expected_size,const char * expression_actual,const char * expression_actual_size)1276 cut_assert_not_equal_memory_helper (const void *expected,
1277 size_t expected_size,
1278 const void *actual,
1279 size_t actual_size,
1280 const char *expression_expected,
1281 const char *expression_expected_size,
1282 const char *expression_actual,
1283 const char *expression_actual_size)
1284 {
1285 if ((expected_size != actual_size) ||
1286 memcmp(expected, actual, expected_size) != 0) {
1287 cut_test_pass();
1288 } else {
1289 const char *message;
1290 const char *inspected_expected;
1291 const char *inspected_actual;
1292
1293 inspected_expected =
1294 cut_take_string(cut_utils_inspect_memory(expected, expected_size));
1295 inspected_actual =
1296 cut_take_string(cut_utils_inspect_memory(actual, actual_size));
1297 message = cut_take_printf(
1298 "<%s(size: %s) != %s(size: %s)>",
1299 expression_expected,
1300 expression_expected_size,
1301 expression_actual,
1302 expression_actual_size);
1303 cut_set_expected(cut_take_printf("%s (size: %" G_GSIZE_FORMAT ")",
1304 inspected_expected, expected_size));
1305 cut_set_actual(cut_take_printf("%s (size: %" G_GSIZE_FORMAT ")",
1306 inspected_actual, actual_size));
1307 cut_test_fail(message);
1308 }
1309 }
1310
1311 void
cut_assert_equal_string_array_helper(char ** expected,char ** actual,const char * expression_expected,const char * expression_actual)1312 cut_assert_equal_string_array_helper (char **expected,
1313 char **actual,
1314 const char *expression_expected,
1315 const char *expression_actual)
1316 {
1317 if (expected && actual &&
1318 cut_utils_equal_string_array(expected, actual)) {
1319 cut_test_pass();
1320 } else {
1321 const gchar *inspected_expected;
1322 const gchar *inspected_actual;
1323 const gchar *message;
1324
1325 inspected_expected = cut_inspect_string_array(expected);
1326 inspected_actual = cut_inspect_string_array(actual);
1327 message = cut_take_printf("<%s == %s>",
1328 expression_expected,
1329 expression_actual);
1330 cut_set_expected(inspected_expected);
1331 cut_set_actual(inspected_actual);
1332 cut_test_fail(message);
1333 }
1334 }
1335
1336 void
cut_assert_operator_helper(cut_boolean result,const char * expression_lhs,const char * expression_operator,const char * expression_rhs)1337 cut_assert_operator_helper (cut_boolean result,
1338 const char *expression_lhs,
1339 const char *expression_operator,
1340 const char *expression_rhs)
1341 {
1342 if (result) {
1343 cut_test_pass();
1344 } else {
1345 cut_test_fail(cut_take_printf("expected: <%s %s %s> is TRUE",
1346 expression_lhs,
1347 expression_operator,
1348 expression_rhs));
1349 }
1350 }
1351
1352 void
cut_assert_operator_int_helper(cut_boolean result,long lhs,long rhs,const char * expression_lhs,const char * expression_operator,const char * expression_rhs)1353 cut_assert_operator_int_helper (cut_boolean result,
1354 long lhs,
1355 long rhs,
1356 const char *expression_lhs,
1357 const char *expression_operator,
1358 const char *expression_rhs)
1359 {
1360 if (result) {
1361 cut_test_pass();
1362 } else {
1363 cut_test_fail(cut_take_printf("expected: <%s> %s <%s>\n"
1364 " actual: <%ld> %s <%ld>",
1365 expression_lhs,
1366 expression_operator,
1367 expression_rhs,
1368 lhs,
1369 expression_operator,
1370 rhs));
1371 }
1372 }
1373
1374 void
cut_assert_operator_uint_helper(cut_boolean result,unsigned long lhs,unsigned long rhs,const char * expression_lhs,const char * expression_operator,const char * expression_rhs)1375 cut_assert_operator_uint_helper (cut_boolean result,
1376 unsigned long lhs,
1377 unsigned long rhs,
1378 const char *expression_lhs,
1379 const char *expression_operator,
1380 const char *expression_rhs)
1381 {
1382 if (result) {
1383 cut_test_pass();
1384 } else {
1385 cut_test_fail(cut_take_printf("expected: <%s> %s <%s>\n"
1386 " actual: <%lu> %s <%lu>",
1387 expression_lhs,
1388 expression_operator,
1389 expression_rhs,
1390 lhs,
1391 expression_operator,
1392 rhs));
1393 }
1394 }
1395
1396 void
cut_assert_operator_size_helper(cut_boolean result,size_t lhs,size_t rhs,const char * expression_lhs,const char * expression_operator,const char * expression_rhs)1397 cut_assert_operator_size_helper (cut_boolean result,
1398 size_t lhs,
1399 size_t rhs,
1400 const char *expression_lhs,
1401 const char *expression_operator,
1402 const char *expression_rhs)
1403 {
1404 if (result) {
1405 cut_test_pass();
1406 } else {
1407 cut_test_fail(cut_take_printf("expected: <%s> %s <%s>\n"
1408 " actual: "
1409 "<%" G_GSIZE_FORMAT ">"
1410 " %s "
1411 "<%" G_GSIZE_FORMAT ">",
1412 expression_lhs,
1413 expression_operator,
1414 expression_rhs,
1415 lhs,
1416 expression_operator,
1417 rhs));
1418 }
1419 }
1420
1421 void
cut_assert_operator_double_helper(cut_boolean result,double lhs,double rhs,const char * expression_lhs,const char * expression_operator,const char * expression_rhs)1422 cut_assert_operator_double_helper (cut_boolean result,
1423 double lhs,
1424 double rhs,
1425 const char *expression_lhs,
1426 const char *expression_operator,
1427 const char *expression_rhs)
1428 {
1429 if (result) {
1430 cut_test_pass();
1431 } else {
1432 cut_test_fail(cut_take_printf("expected: <%s> %s <%s>\n"
1433 " actual: <%g> %s <%g>",
1434 expression_lhs,
1435 expression_operator,
1436 expression_rhs,
1437 lhs,
1438 expression_operator,
1439 rhs));
1440 }
1441 }
1442
1443 void
cut_assert_equal_helper(cut_boolean result,const char * expression_function,const char * expression_expected,const char * expression_actual)1444 cut_assert_equal_helper (cut_boolean result,
1445 const char *expression_function,
1446 const char *expression_expected,
1447 const char *expression_actual)
1448 {
1449 if (result) {
1450 cut_test_pass();
1451 } else {
1452 cut_test_fail(cut_take_printf("expected: <%s(%s, %s)> is TRUE",
1453 expression_function,
1454 expression_expected,
1455 expression_actual));
1456 }
1457 }
1458
1459 void
cut_assert_errno_helper(void)1460 cut_assert_errno_helper (void)
1461 {
1462 int current_errno = errno;
1463
1464 if (current_errno == 0) {
1465 cut_test_pass();
1466 } else {
1467 cut_test_fail(cut_take_printf("expected: <0> (errno)\n"
1468 " actual: <%d> (%s)",
1469 current_errno,
1470 g_strerror(current_errno)));
1471 }
1472 }
1473
1474 void
cut_assert_exist_path_helper(const char * path,const char * expression_path)1475 cut_assert_exist_path_helper (const char *path,
1476 const char *expression_path)
1477 {
1478 if (!path) {
1479 cut_test_fail(cut_take_printf("<%s>\n"
1480 "expected: <%s> "
1481 "should not be NULL",
1482 expression_path,
1483 path));
1484 } else if (cut_utils_path_exist(path)) {
1485 cut_test_pass();
1486 } else {
1487 cut_test_fail(cut_take_printf("<%s>\n"
1488 "expected: <%s> exists",
1489 expression_path,
1490 path));
1491 }
1492 }
1493
1494 void
cut_assert_not_exist_path_helper(const char * path,const char * expression_path)1495 cut_assert_not_exist_path_helper (const char *path,
1496 const char *expression_path)
1497 {
1498 if (!path) {
1499 cut_test_fail(cut_take_printf("<%s>\n"
1500 "expected: <%s> "
1501 "should not be NULL",
1502 expression_path,
1503 path));
1504 } else if (!cut_utils_path_exist(path)) {
1505 cut_test_pass();
1506 } else {
1507 cut_test_fail(cut_take_printf("<%s>\n"
1508 "expected: <%s> "
1509 "doesn't exist",
1510 expression_path,
1511 path));
1512 }
1513 }
1514
1515 void
cut_assert_match_helper(const char * pattern,const char * actual,const char * expression_pattern,const char * expression_actual)1516 cut_assert_match_helper (const char *pattern,
1517 const char *actual,
1518 const char *expression_pattern,
1519 const char *expression_actual)
1520 {
1521 if (cut_utils_regex_match(pattern, actual)) {
1522 cut_test_pass();
1523 } else {
1524 cut_test_fail(cut_take_printf("<%s> =~ <%s>\n"
1525 " pattern: <%s>\n"
1526 " actual: <%s>",
1527 expression_pattern,
1528 expression_actual,
1529 pattern, actual));
1530 }
1531 }
1532
1533 void
cut_assert_equal_pointer_helper(const void * expected,const void * actual,const char * expression_expected,const char * expression_actual)1534 cut_assert_equal_pointer_helper (const void *expected,
1535 const void *actual,
1536 const char *expression_expected,
1537 const char *expression_actual)
1538 {
1539 if (expected == actual) {
1540 cut_test_pass();
1541 } else {
1542 cut_test_fail(cut_take_printf("<%s == %s>\n"
1543 "expected: <%p>\n"
1544 " actual: <%p>",
1545 expression_expected,
1546 expression_actual,
1547 expected, actual));
1548 }
1549 }
1550
1551 void
cut_assert_equal_fixture_data_string_helper(const char * expected,const char * expression_expected,const char * path,...)1552 cut_assert_equal_fixture_data_string_helper (const char *expected,
1553 const char *expression_expected,
1554 const char *path,
1555 ...)
1556 {
1557 GError *error = NULL;
1558 const gchar *data;
1559 const gchar *full_path;
1560 va_list args;
1561
1562 va_start(args, path);
1563 data = cut_utils_get_fixture_data_va_list(
1564 cut_get_current_test_context(), &full_path, NULL, path, args);
1565 cut_test_context_keep_user_message(cut_get_current_test_context());
1566 gcut_assert_error_helper(error, expression_expected);
1567 cut_assert_equal_string_helper(expected, data,
1568 expression_expected,
1569 full_path);
1570 }
1571
1572 void
cut_assert_equal_file_raw_helper(const char * expected,const char * actual,const char * expression_expected,const char * expression_actual)1573 cut_assert_equal_file_raw_helper (const char *expected,
1574 const char *actual,
1575 const char *expression_expected,
1576 const char *expression_actual)
1577 {
1578 GError *error = NULL;
1579 gchar *expected_data = NULL;
1580 gchar *actual_data = NULL;
1581 gsize expected_size;
1582 gsize actual_size;
1583
1584 g_file_get_contents(expected, &expected_data, &expected_size, &error);
1585 gcut_assert_error_helper(error, expression_expected);
1586 cut_take_string(expected_data);
1587
1588 g_file_get_contents(actual, &actual_data, &actual_size, &error);
1589 gcut_assert_error_helper(error, expression_actual);
1590 cut_take_string(actual_data);
1591
1592 if ((expected_size == actual_size) &&
1593 memcmp(expected_data, actual_data, expected_size) == 0) {
1594 cut_test_pass();
1595 } else {
1596 const char *message;
1597 const char *inspected_expected;
1598 const char *inspected_actual;
1599
1600 inspected_expected =
1601 cut_take_string(cut_utils_inspect_memory(expected_data,
1602 expected_size));
1603 inspected_actual =
1604 cut_take_string(cut_utils_inspect_memory(actual_data, actual_size));
1605 message = cut_take_printf("<content(%s) == content(%s)>",
1606 expression_expected,
1607 expression_actual);
1608 cut_set_expected(cut_take_printf("path: <%s>\n"
1609 "%s (size: %" G_GSIZE_FORMAT ")",
1610 expected,
1611 inspected_expected,
1612 expected_size));
1613 cut_set_actual(cut_take_printf("path: <%s>\n"
1614 "%s (size: %" G_GSIZE_FORMAT ")",
1615 actual,
1616 inspected_actual,
1617 actual_size));
1618 cut_test_fail(message);
1619 }
1620 }
1621
1622 void
cut_assert_not_equal_file_raw_helper(const char * expected,const char * actual,const char * expression_expected,const char * expression_actual)1623 cut_assert_not_equal_file_raw_helper (const char *expected,
1624 const char *actual,
1625 const char *expression_expected,
1626 const char *expression_actual)
1627 {
1628 GError *error = NULL;
1629 gchar *expected_data = NULL;
1630 gchar *actual_data = NULL;
1631 gsize expected_size;
1632 gsize actual_size;
1633
1634 g_file_get_contents(expected, &expected_data, &expected_size, &error);
1635 gcut_assert_error_helper(error, expression_expected);
1636 cut_take_string(expected_data);
1637
1638 g_file_get_contents(actual, &actual_data, &actual_size, &error);
1639 gcut_assert_error_helper(error, expression_actual);
1640 cut_take_string(actual_data);
1641
1642 if ((expected_size != actual_size) ||
1643 memcmp(expected_data, actual_data, expected_size) != 0) {
1644 cut_test_pass();
1645 } else {
1646 const char *message;
1647 const char *inspected_expected;
1648 const char *inspected_actual;
1649
1650 inspected_expected =
1651 cut_take_string(cut_utils_inspect_memory(expected_data,
1652 expected_size));
1653 inspected_actual =
1654 cut_take_string(cut_utils_inspect_memory(actual_data, actual_size));
1655 message = cut_take_printf("<content(%s) != content(%s)>",
1656 expression_expected,
1657 expression_actual);
1658 cut_set_expected(cut_take_printf("path: <%s>\n"
1659 "%s (size: %" G_GSIZE_FORMAT ")",
1660 expected,
1661 inspected_expected,
1662 expected_size));
1663 cut_set_actual(cut_take_printf("path: <%s>\n"
1664 "%s (size: %" G_GSIZE_FORMAT ")",
1665 actual,
1666 inspected_actual,
1667 actual_size));
1668 cut_test_fail(message);
1669 }
1670 }
1671
1672 #ifndef CUT_DISABLE_SOCKET_SUPPORT
1673 void
cut_assert_equal_sockaddr_helper(const struct sockaddr * expected,const struct sockaddr * actual,const char * expression_expected,const char * expression_actual)1674 cut_assert_equal_sockaddr_helper (const struct sockaddr *expected,
1675 const struct sockaddr *actual,
1676 const char *expression_expected,
1677 const char *expression_actual)
1678 {
1679 if (cut_equal_sockaddr(expected, actual)) {
1680 cut_test_pass();
1681 } else {
1682 cut_set_expected(cut_inspect_sockaddr(expected));
1683 cut_set_actual(cut_inspect_sockaddr(actual));
1684 cut_test_fail(cut_take_printf("<%s == %s>",
1685 expression_expected,
1686 expression_actual));
1687 }
1688 }
1689 #endif
1690
1691 void
cut_error_errno_helper(void)1692 cut_error_errno_helper (void)
1693 {
1694 int current_errno = errno;
1695
1696 if (current_errno != 0) {
1697 cut_test_terminate(ERROR,
1698 cut_take_printf("<%d> (%s)",
1699 current_errno,
1700 g_strerror(current_errno)));
1701 }
1702 }
1703
1704 /*
1705 vi:ts=4:nowrap:ai:expandtab:sw=4
1706 */
1707