cmocka  0.4.0
cmocka.h
1 /*
2  * Copyright 2008 Google Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #ifndef CMOCKA_H_
17 #define CMOCKA_H_
18 
19 #ifdef _WIN32
20 # ifdef _MSC_VER
21 
22 # ifndef inline
23 #define inline __inline
24 # endif /* inline */
25 
26 # if _MSC_VER < 1500
27 # ifdef __cplusplus
28 extern "C" {
29 # endif /* __cplusplus */
30 int __stdcall IsDebuggerPresent();
31 # ifdef __cplusplus
32 } /* extern "C" */
33 # endif /* __cplusplus */
34 # endif /* _MSC_VER < 1500 */
35 # endif /* _MSC_VER */
36 #endif /* _WIN32 */
37 
38 /*
39  * These headers or their equivalents should be included prior to including
40  * this header file.
41  *
42  * #include <stdarg.h>
43  * #include <stddef.h>
44  * #include <setjmp.h>
45  *
46  * This allows test applications to use custom definitions of C standard
47  * library functions and types.
48  */
49 
50 /* For those who are used to __func__ from gcc. */
51 #ifndef __func__
52 #define __func__ __FUNCTION__
53 #endif
54 
55 /* GCC have printf type attribute check. */
56 #ifdef __GNUC__
57 #define CMOCKA_PRINTF_ATTRIBUTE(a,b) \
58  __attribute__ ((__format__ (__printf__, a, b)))
59 #else
60 #define CMOCKA_PRINTF_ATTRIBUTE(a,b)
61 #endif /* __GNUC__ */
62 
71 /*
72  * Largest integral type. This type should be large enough to hold any
73  * pointer or integer supported by the compiler.
74  */
75 #ifndef LargestIntegralType
76 #define LargestIntegralType unsigned long long
77 #endif /* LargestIntegralType */
78 
79 /* Printf format used to display LargestIntegralType. */
80 #ifndef LargestIntegralTypePrintfFormat
81 #ifdef _WIN32
82 #define LargestIntegralTypePrintfFormat "0x%I64x"
83 #else
84 #define LargestIntegralTypePrintfFormat "%#llx"
85 #endif /* _WIN32 */
86 #endif /* LargestIntegralTypePrintfFormat */
87 
88 /* Perform an unsigned cast to LargestIntegralType. */
89 #define cast_to_largest_integral_type(value) \
90  ((LargestIntegralType)((size_t)(value)))
91 
92 /* Smallest integral type capable of holding a pointer. */
93 #if !defined(_UINTPTR_T) && !defined(_UINTPTR_T_DEFINED)
94 # if defined(_WIN32)
95  /* WIN32 is an ILP32 platform */
96  typedef unsigned int uintptr_t;
97 # elif defined(_WIN64)
98  typedef unsigned long int uintptr_t
99 # else /* _WIN32 */
100 
101 /* ILP32 and LP64 platforms */
102 # ifdef __WORDSIZE /* glibc */
103 # if __WORDSIZE == 64
104  typedef unsigned long int uintptr_t;
105 # else
106  typedef unsigned int uintptr_t;
107 # endif /* __WORDSIZE == 64 */
108 # else /* __WORDSIZE */
109 # if defined(_LP64) || defined(_I32LPx)
110  typedef unsigned long int uintptr_t;
111 # else
112  typedef unsigned int uintptr_t;
113 # endif
114 # endif /* __WORDSIZE */
115 # endif /* _WIN32 */
116 
117 # define _UINTPTR_T
118 # define _UINTPTR_T_DEFINED
119 #endif /* !defined(_UINTPTR_T) || !defined(_UINTPTR_T_DEFINED) */
120 
121 /* Perform an unsigned cast to uintptr_t. */
122 #define cast_to_pointer_integral_type(value) \
123  ((uintptr_t)(value))
124 
125 /* Perform a cast of a pointer to uintmax_t */
126 #define cast_ptr_to_largest_integral_type(value) \
127 cast_to_largest_integral_type(cast_to_pointer_integral_type(value))
128 
177 #ifdef DOXYGEN
178 
185 void *mock(void);
186 #else
187 #define mock() _mock(__func__, __FILE__, __LINE__)
188 #endif
189 
190 #ifdef DOXYGEN
191 
211 void *mock_type(#type);
212 #else
213 #define mock_type(type) ((type) mock())
214 #endif
215 
216 #ifdef DOXYGEN
217 
238 void *mock_ptr_type(#type);
239 #else
240 #define mock_ptr_type(type) ((type) (uintptr_t) mock())
241 #endif
242 
243 
244 #ifdef DOXYGEN
245 
269 void will_return(#function, void *value);
270 #else
271 #define will_return(function, value) \
272  _will_return(#function, __FILE__, __LINE__, \
273  cast_to_largest_integral_type(value), 1)
274 #endif
275 
276 #ifdef DOXYGEN
277 
290 void will_return_count(#function, void *value, int count);
291 #else
292 #define will_return_count(function, value, count) \
293  _will_return(#function, __FILE__, __LINE__, \
294  cast_to_largest_integral_type(value), count)
295 #endif
296 
297 #ifdef DOXYGEN
298 
313 void will_return_always(#function, void *value);
314 #else
315 #define will_return_always(function, value) \
316  will_return_count(function, (value), -1)
317 #endif
318 
365 /*
366  * Add a custom parameter checking function. If the event parameter is NULL
367  * the event structure is allocated internally by this function. If event
368  * parameter is provided it must be allocated on the heap and doesn't need to
369  * be deallocated by the caller.
370  */
371 #ifdef DOXYGEN
372 
388 void expect_check(#function, #parameter, #check_function, const void *check_data);
389 #else
390 #define expect_check(function, parameter, check_function, check_data) \
391  _expect_check(#function, #parameter, __FILE__, __LINE__, check_function, \
392  cast_to_largest_integral_type(check_data), NULL, 0)
393 #endif
394 
395 #ifdef DOXYGEN
396 
410 void expect_in_set(#function, #parameter, uintmax_t value_array[]);
411 #else
412 #define expect_in_set(function, parameter, value_array) \
413  expect_in_set_count(function, parameter, value_array, 1)
414 #endif
415 
416 #ifdef DOXYGEN
417 
435 void expect_in_set_count(#function, #parameter, uintmax_t value_array[], size_t count);
436 #else
437 #define expect_in_set_count(function, parameter, value_array, count) \
438  _expect_in_set(#function, #parameter, __FILE__, __LINE__, value_array, \
439  sizeof(value_array) / sizeof((value_array)[0]), count)
440 #endif
441 
442 #ifdef DOXYGEN
443 
457 void expect_not_in_set(#function, #parameter, uintmax_t value_array[]);
458 #else
459 #define expect_not_in_set(function, parameter, value_array) \
460  expect_not_in_set_count(function, parameter, value_array, 1)
461 #endif
462 
463 #ifdef DOXYGEN
464 
482 void expect_not_in_set_count(#function, #parameter, uintmax_t value_array[], size_t count);
483 #else
484 #define expect_not_in_set_count(function, parameter, value_array, count) \
485  _expect_not_in_set( \
486  #function, #parameter, __FILE__, __LINE__, value_array, \
487  sizeof(value_array) / sizeof((value_array)[0]), count)
488 #endif
489 
490 
491 #ifdef DOXYGEN
492 
508 void expect_in_range(#function, #parameter, uintmax_t minimum, uintmax_t maximum);
509 #else
510 #define expect_in_range(function, parameter, minimum, maximum) \
511  expect_in_range_count(function, parameter, minimum, maximum, 1)
512 #endif
513 
514 #ifdef DOXYGEN
515 
535 void expect_in_range_count(#function, #parameter, uintmax_t minimum, uintmax_t maximum, size_t count);
536 #else
537 #define expect_in_range_count(function, parameter, minimum, maximum, count) \
538  _expect_in_range(#function, #parameter, __FILE__, __LINE__, minimum, \
539  maximum, count)
540 #endif
541 
542 #ifdef DOXYGEN
543 
559 void expect_not_in_range(#function, #parameter, uintmax_t minimum, uintmax_t maximum);
560 #else
561 #define expect_not_in_range(function, parameter, minimum, maximum) \
562  expect_not_in_range_count(function, parameter, minimum, maximum, 1)
563 #endif
564 
565 #ifdef DOXYGEN
566 
586 void expect_not_in_range_count(#function, #parameter, uintmax_t minimum, uintmax_t maximum, size_t count);
587 #else
588 #define expect_not_in_range_count(function, parameter, minimum, maximum, \
589  count) \
590  _expect_not_in_range(#function, #parameter, __FILE__, __LINE__, \
591  minimum, maximum, count)
592 #endif
593 
594 #ifdef DOXYGEN
595 
608 void expect_value(#function, #parameter, uintmax_t value);
609 #else
610 #define expect_value(function, parameter, value) \
611  expect_value_count(function, parameter, value, 1)
612 #endif
613 
614 #ifdef DOXYGEN
615 
632 void expect_value_count(#function, #parameter, uintmax_t value, size_t count);
633 #else
634 #define expect_value_count(function, parameter, value, count) \
635  _expect_value(#function, #parameter, __FILE__, __LINE__, \
636  cast_to_largest_integral_type(value), count)
637 #endif
638 
639 #ifdef DOXYGEN
640 
653 void expect_not_value(#function, #parameter, uintmax_t value);
654 #else
655 #define expect_not_value(function, parameter, value) \
656  expect_not_value_count(function, parameter, value, 1)
657 #endif
658 
659 #ifdef DOXYGEN
660 
677 void expect_not_value_count(#function, #parameter, uintmax_t value, size_t count);
678 #else
679 #define expect_not_value_count(function, parameter, value, count) \
680  _expect_not_value(#function, #parameter, __FILE__, __LINE__, \
681  cast_to_largest_integral_type(value), count)
682 #endif
683 
684 #ifdef DOXYGEN
685 
699 void expect_string(#function, #parameter, const char *string);
700 #else
701 #define expect_string(function, parameter, string) \
702  expect_string_count(function, parameter, string, 1)
703 #endif
704 
705 #ifdef DOXYGEN
706 
724 void expect_string_count(#function, #parameter, const char *string, size_t count);
725 #else
726 #define expect_string_count(function, parameter, string, count) \
727  _expect_string(#function, #parameter, __FILE__, __LINE__, \
728  (const char*)(string), count)
729 #endif
730 
731 #ifdef DOXYGEN
732 
746 void expect_not_string(#function, #parameter, const char *string);
747 #else
748 #define expect_not_string(function, parameter, string) \
749  expect_not_string_count(function, parameter, string, 1)
750 #endif
751 
752 #ifdef DOXYGEN
753 
771 void expect_not_string_count(#function, #parameter, const char *string, size_t count);
772 #else
773 #define expect_not_string_count(function, parameter, string, count) \
774  _expect_not_string(#function, #parameter, __FILE__, __LINE__, \
775  (const char*)(string), count)
776 #endif
777 
778 #ifdef DOXYGEN
779 
794 void expect_memory(#function, #parameter, void *memory, size_t size);
795 #else
796 #define expect_memory(function, parameter, memory, size) \
797  expect_memory_count(function, parameter, memory, size, 1)
798 #endif
799 
800 #ifdef DOXYGEN
801 
821 void expect_memory_count(#function, #parameter, void *memory, size_t size, size_t count);
822 #else
823 #define expect_memory_count(function, parameter, memory, size, count) \
824  _expect_memory(#function, #parameter, __FILE__, __LINE__, \
825  (const void*)(memory), size, count)
826 #endif
827 
828 #ifdef DOXYGEN
829 
845 void expect_not_memory(#function, #parameter, void *memory, size_t size);
846 #else
847 #define expect_not_memory(function, parameter, memory, size) \
848  expect_not_memory_count(function, parameter, memory, size, 1)
849 #endif
850 
851 #ifdef DOXYGEN
852 
872 void expect_not_memory_count(#function, #parameter, void *memory, size_t size, size_t count);
873 #else
874 #define expect_not_memory_count(function, parameter, memory, size, count) \
875  _expect_not_memory(#function, #parameter, __FILE__, __LINE__, \
876  (const void*)(memory), size, count)
877 #endif
878 
879 
880 #ifdef DOXYGEN
881 
892 void expect_any(#function, #parameter);
893 #else
894 #define expect_any(function, parameter) \
895  expect_any_count(function, parameter, 1)
896 #endif
897 
898 #ifdef DOXYGEN
899 
915 void expect_any_count(#function, #parameter, size_t count);
916 #else
917 #define expect_any_count(function, parameter, count) \
918  _expect_any(#function, #parameter, __FILE__, __LINE__, count)
919 #endif
920 
921 #ifdef DOXYGEN
922 
932 void check_expected(#parameter);
933 #else
934 #define check_expected(parameter) \
935  _check_expected(__func__, #parameter, __FILE__, __LINE__, \
936  cast_to_largest_integral_type(parameter))
937 #endif
938 
960 #ifdef DOXYGEN
961 
973 void assert_true(scalar expression);
974 #else
975 #define assert_true(c) _assert_true(cast_to_largest_integral_type(c), #c, \
976  __FILE__, __LINE__)
977 #endif
978 
979 #ifdef DOXYGEN
980 
991 void assert_false(scalar expression);
992 #else
993 #define assert_false(c) _assert_true(!(cast_to_largest_integral_type(c)), #c, \
994  __FILE__, __LINE__)
995 #endif
996 
997 #ifdef DOXYGEN
998 
1010 void assert_return_code(int rc, int error);
1011 #else
1012 #define assert_return_code(rc, error) \
1013  _assert_return_code(cast_to_largest_integral_type(rc), \
1014  sizeof(rc), \
1015  cast_to_largest_integral_type(error), \
1016  #rc, __FILE__, __LINE__)
1017 #endif
1018 
1019 #ifdef DOXYGEN
1020 
1030 void assert_non_null(void *pointer);
1031 #else
1032 #define assert_non_null(c) _assert_true(cast_ptr_to_largest_integral_type(c), #c, \
1033  __FILE__, __LINE__)
1034 #endif
1035 
1036 #ifdef DOXYGEN
1037 
1047 void assert_null(void *pointer);
1048 #else
1049 #define assert_null(c) _assert_true(!(cast_ptr_to_largest_integral_type(c)), #c, \
1050 __FILE__, __LINE__)
1051 #endif
1052 
1053 #ifdef DOXYGEN
1054 
1064 void assert_int_equal(int a, int b);
1065 #else
1066 #define assert_int_equal(a, b) \
1067  _assert_int_equal(cast_to_largest_integral_type(a), \
1068  cast_to_largest_integral_type(b), \
1069  __FILE__, __LINE__)
1070 #endif
1071 
1072 #ifdef DOXYGEN
1073 
1085 void assert_int_not_equal(int a, int b);
1086 #else
1087 #define assert_int_not_equal(a, b) \
1088  _assert_int_not_equal(cast_to_largest_integral_type(a), \
1089  cast_to_largest_integral_type(b), \
1090  __FILE__, __LINE__)
1091 #endif
1092 
1093 #ifdef DOXYGEN
1094 
1104 void assert_string_equal(const char *a, const char *b);
1105 #else
1106 #define assert_string_equal(a, b) \
1107  _assert_string_equal((const char*)(a), (const char*)(b), __FILE__, \
1108  __LINE__)
1109 #endif
1110 
1111 #ifdef DOXYGEN
1112 
1122 void assert_string_not_equal(const char *a, const char *b);
1123 #else
1124 #define assert_string_not_equal(a, b) \
1125  _assert_string_not_equal((const char*)(a), (const char*)(b), __FILE__, \
1126  __LINE__)
1127 #endif
1128 
1129 #ifdef DOXYGEN
1130 
1144 void assert_memory_equal(const void *a, const void *b, size_t size);
1145 #else
1146 #define assert_memory_equal(a, b, size) \
1147  _assert_memory_equal((const void*)(a), (const void*)(b), size, __FILE__, \
1148  __LINE__)
1149 #endif
1150 
1151 #ifdef DOXYGEN
1152 
1166 void assert_memory_not_equal(const void *a, const void *b, size_t size);
1167 #else
1168 #define assert_memory_not_equal(a, b, size) \
1169  _assert_memory_not_equal((const void*)(a), (const void*)(b), size, \
1170  __FILE__, __LINE__)
1171 #endif
1172 
1173 #ifdef DOXYGEN
1174 
1187 void assert_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum);
1188 #else
1189 #define assert_in_range(value, minimum, maximum) \
1190  _assert_in_range( \
1191  cast_to_largest_integral_type(value), \
1192  cast_to_largest_integral_type(minimum), \
1193  cast_to_largest_integral_type(maximum), __FILE__, __LINE__)
1194 #endif
1195 
1196 #ifdef DOXYGEN
1197 
1210 void assert_not_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum);
1211 #else
1212 #define assert_not_in_range(value, minimum, maximum) \
1213  _assert_not_in_range( \
1214  cast_to_largest_integral_type(value), \
1215  cast_to_largest_integral_type(minimum), \
1216  cast_to_largest_integral_type(maximum), __FILE__, __LINE__)
1217 #endif
1218 
1219 #ifdef DOXYGEN
1220 
1232 void assert_in_set(uintmax_t value, uintmax_t values[], size_t count);
1233 #else
1234 #define assert_in_set(value, values, number_of_values) \
1235  _assert_in_set(value, values, number_of_values, __FILE__, __LINE__)
1236 #endif
1237 
1238 #ifdef DOXYGEN
1239 
1251 void assert_not_in_set(uintmax_t value, uintmax_t values[], size_t count);
1252 #else
1253 #define assert_not_in_set(value, values, number_of_values) \
1254  _assert_not_in_set(value, values, number_of_values, __FILE__, __LINE__)
1255 #endif
1256 
1285 #ifdef DOXYGEN
1286 
1289 void fail(void);
1290 #else
1291 #define fail() _fail(__FILE__, __LINE__)
1292 #endif
1293 
1294 #ifdef DOXYGEN
1295 
1298 void fail_msg(const char *msg, ...);
1299 #else
1300 #define fail_msg(msg, ...) do { \
1301  print_error("ERROR: " msg "\n", ##__VA_ARGS__); \
1302  fail(); \
1303 } while (0)
1304 #endif
1305 
1306 #ifdef DOXYGEN
1307 
1324 int run_test(#function);
1325 #else
1326 #define run_test(f) _run_test(#f, f, NULL, UNIT_TEST_FUNCTION_TYPE_TEST, NULL)
1327 #endif
1328 
1329 static inline void _unit_test_dummy(void **state) {
1330  (void)state;
1331 }
1332 
1334 #define unit_test(f) { #f, f, UNIT_TEST_FUNCTION_TYPE_TEST }
1335 
1336 #define _unit_test_setup(test, setup) \
1337  { #test "_" #setup, setup, UNIT_TEST_FUNCTION_TYPE_SETUP }
1338 
1340 #define unit_test_setup(test, setup) \
1341  _unit_test_setup(test, setup), \
1342  unit_test(test), \
1343  _unit_test_teardown(test, _unit_test_dummy)
1344 
1345 #define _unit_test_teardown(test, teardown) \
1346  { #test "_" #teardown, teardown, UNIT_TEST_FUNCTION_TYPE_TEARDOWN }
1347 
1349 #define unit_test_teardown(test, teardown) \
1350  _unit_test_setup(test, _unit_test_dummy), \
1351  unit_test(test), \
1352  _unit_test_teardown(test, teardown)
1353 
1354 #define group_test_setup(setup) \
1355  { "group_" #setup, setup, UNIT_TEST_FUNCTION_TYPE_GROUP_SETUP }
1356 
1357 #define group_test_teardown(teardown) \
1358  { "group_" #teardown, teardown, UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN }
1359 
1364 #define unit_test_setup_teardown(test, setup, teardown) \
1365  _unit_test_setup(test, setup), \
1366  unit_test(test), \
1367  _unit_test_teardown(test, teardown)
1368 
1369 #ifdef DOXYGEN
1370 
1415 int run_tests(const UnitTest tests[]);
1416 #else
1417 #define run_tests(tests) _run_tests(tests, sizeof(tests) / sizeof(tests)[0])
1418 #endif
1419 
1420 #define run_group_tests(tests) _run_group_tests(tests, sizeof(tests) / sizeof(tests)[0])
1421 
1447 #ifdef DOXYGEN
1448 
1470 void *test_malloc(size_t size);
1471 #else
1472 #define test_malloc(size) _test_malloc(size, __FILE__, __LINE__)
1473 #endif
1474 
1475 #ifdef DOXYGEN
1476 
1489 void *test_calloc(size_t nmemb, size_t size);
1490 #else
1491 #define test_calloc(num, size) _test_calloc(num, size, __FILE__, __LINE__)
1492 #endif
1493 
1494 #ifdef DOXYGEN
1495 
1502 void test_free(void *ptr);
1503 #else
1504 #define test_free(ptr) _test_free(ptr, __FILE__, __LINE__)
1505 #endif
1506 
1507 /* Redirect malloc, calloc and free to the unit test allocators. */
1508 #ifdef UNIT_TESTING
1509 #define malloc test_malloc
1510 #define calloc test_calloc
1511 #define free test_free
1512 #endif /* UNIT_TESTING */
1513 
1567 void mock_assert(const int result, const char* const expression,
1568  const char * const file, const int line);
1569 
1570 #ifdef DOXYGEN
1571 
1593 void expect_assert_failure(function fn_call);
1594 #else
1595 #define expect_assert_failure(function_call) \
1596  { \
1597  const int result = setjmp(global_expect_assert_env); \
1598  global_expecting_assert = 1; \
1599  if (result) { \
1600  print_message("Expected assertion %s occurred\n", \
1601  global_last_failed_assert); \
1602  global_expecting_assert = 0; \
1603  } else { \
1604  function_call ; \
1605  global_expecting_assert = 0; \
1606  print_error("Expected assert in %s\n", #function_call); \
1607  _fail(__FILE__, __LINE__); \
1608  } \
1609  }
1610 #endif
1611 
1614 /* Function prototype for setup, test and teardown functions. */
1615 typedef void (*UnitTestFunction)(void **state);
1616 
1617 /* Function that determines whether a function parameter value is correct. */
1618 typedef int (*CheckParameterValue)(const LargestIntegralType value,
1619  const LargestIntegralType check_value_data);
1620 
1621 /* Type of the unit test function. */
1622 typedef enum UnitTestFunctionType {
1623  UNIT_TEST_FUNCTION_TYPE_TEST = 0,
1624  UNIT_TEST_FUNCTION_TYPE_SETUP,
1625  UNIT_TEST_FUNCTION_TYPE_TEARDOWN,
1626  UNIT_TEST_FUNCTION_TYPE_GROUP_SETUP,
1627  UNIT_TEST_FUNCTION_TYPE_GROUP_TEARDOWN,
1628 } UnitTestFunctionType;
1629 
1630 /*
1631  * Stores a unit test function with its name and type.
1632  * NOTE: Every setup function must be paired with a teardown function. It's
1633  * possible to specify NULL function pointers.
1634  */
1635 typedef struct UnitTest {
1636  const char* name;
1637  UnitTestFunction function;
1638  UnitTestFunctionType function_type;
1639 } UnitTest;
1640 
1641 typedef struct GroupTest {
1642  UnitTestFunction setup;
1643  UnitTestFunction teardown;
1644  const UnitTest *tests;
1645  const size_t number_of_tests;
1646 } GroupTest;
1647 
1648 /* Location within some source code. */
1649 typedef struct SourceLocation {
1650  const char* file;
1651  int line;
1652 } SourceLocation;
1653 
1654 /* Event that's called to check a parameter value. */
1655 typedef struct CheckParameterEvent {
1656  SourceLocation location;
1657  const char *parameter_name;
1658  CheckParameterValue check_value;
1659  LargestIntegralType check_value_data;
1660 } CheckParameterEvent;
1661 
1662 /* Used by expect_assert_failure() and mock_assert(). */
1663 extern int global_expecting_assert;
1664 extern jmp_buf global_expect_assert_env;
1665 extern const char * global_last_failed_assert;
1666 
1667 /* Retrieves a value for the given function, as set by "will_return". */
1668 LargestIntegralType _mock(const char * const function, const char* const file,
1669  const int line);
1670 
1671 void _expect_check(
1672  const char* const function, const char* const parameter,
1673  const char* const file, const int line,
1674  const CheckParameterValue check_function,
1675  const LargestIntegralType check_data, CheckParameterEvent * const event,
1676  const int count);
1677 
1678 void _expect_in_set(
1679  const char* const function, const char* const parameter,
1680  const char* const file, const int line, const LargestIntegralType values[],
1681  const size_t number_of_values, const int count);
1682 void _expect_not_in_set(
1683  const char* const function, const char* const parameter,
1684  const char* const file, const int line, const LargestIntegralType values[],
1685  const size_t number_of_values, const int count);
1686 
1687 void _expect_in_range(
1688  const char* const function, const char* const parameter,
1689  const char* const file, const int line,
1690  const LargestIntegralType minimum,
1691  const LargestIntegralType maximum, const int count);
1692 void _expect_not_in_range(
1693  const char* const function, const char* const parameter,
1694  const char* const file, const int line,
1695  const LargestIntegralType minimum,
1696  const LargestIntegralType maximum, const int count);
1697 
1698 void _expect_value(
1699  const char* const function, const char* const parameter,
1700  const char* const file, const int line, const LargestIntegralType value,
1701  const int count);
1702 void _expect_not_value(
1703  const char* const function, const char* const parameter,
1704  const char* const file, const int line, const LargestIntegralType value,
1705  const int count);
1706 
1707 void _expect_string(
1708  const char* const function, const char* const parameter,
1709  const char* const file, const int line, const char* string,
1710  const int count);
1711 void _expect_not_string(
1712  const char* const function, const char* const parameter,
1713  const char* const file, const int line, const char* string,
1714  const int count);
1715 
1716 void _expect_memory(
1717  const char* const function, const char* const parameter,
1718  const char* const file, const int line, const void* const memory,
1719  const size_t size, const int count);
1720 void _expect_not_memory(
1721  const char* const function, const char* const parameter,
1722  const char* const file, const int line, const void* const memory,
1723  const size_t size, const int count);
1724 
1725 void _expect_any(
1726  const char* const function, const char* const parameter,
1727  const char* const file, const int line, const int count);
1728 
1729 void _check_expected(
1730  const char * const function_name, const char * const parameter_name,
1731  const char* file, const int line, const LargestIntegralType value);
1732 
1733 void _will_return(const char * const function_name, const char * const file,
1734  const int line, const LargestIntegralType value,
1735  const int count);
1736 void _assert_true(const LargestIntegralType result,
1737  const char* const expression,
1738  const char * const file, const int line);
1739 void _assert_return_code(const LargestIntegralType result,
1740  size_t rlen,
1741  const LargestIntegralType error,
1742  const char * const expression,
1743  const char * const file,
1744  const int line);
1745 void _assert_int_equal(
1746  const LargestIntegralType a, const LargestIntegralType b,
1747  const char * const file, const int line);
1748 void _assert_int_not_equal(
1749  const LargestIntegralType a, const LargestIntegralType b,
1750  const char * const file, const int line);
1751 void _assert_string_equal(const char * const a, const char * const b,
1752  const char * const file, const int line);
1753 void _assert_string_not_equal(const char * const a, const char * const b,
1754  const char *file, const int line);
1755 void _assert_memory_equal(const void * const a, const void * const b,
1756  const size_t size, const char* const file,
1757  const int line);
1758 void _assert_memory_not_equal(const void * const a, const void * const b,
1759  const size_t size, const char* const file,
1760  const int line);
1761 void _assert_in_range(
1762  const LargestIntegralType value, const LargestIntegralType minimum,
1763  const LargestIntegralType maximum, const char* const file, const int line);
1764 void _assert_not_in_range(
1765  const LargestIntegralType value, const LargestIntegralType minimum,
1766  const LargestIntegralType maximum, const char* const file, const int line);
1767 void _assert_in_set(
1768  const LargestIntegralType value, const LargestIntegralType values[],
1769  const size_t number_of_values, const char* const file, const int line);
1770 void _assert_not_in_set(
1771  const LargestIntegralType value, const LargestIntegralType values[],
1772  const size_t number_of_values, const char* const file, const int line);
1773 
1774 void* _test_malloc(const size_t size, const char* file, const int line);
1775 void* _test_calloc(const size_t number_of_elements, const size_t size,
1776  const char* file, const int line);
1777 void _test_free(void* const ptr, const char* file, const int line);
1778 
1779 void _fail(const char * const file, const int line);
1780 int _run_test(
1781  const char * const function_name, const UnitTestFunction Function,
1782  void ** const volatile state, const UnitTestFunctionType function_type,
1783  const void* const heap_check_point);
1784 int _run_tests(const UnitTest * const tests, const size_t number_of_tests);
1785 int _run_group_tests(const UnitTest * const tests,
1786  const size_t number_of_tests);
1787 
1788 /* Standard output and error print methods. */
1789 void print_message(const char* const format, ...) CMOCKA_PRINTF_ATTRIBUTE(1, 2);
1790 void print_error(const char* const format, ...) CMOCKA_PRINTF_ATTRIBUTE(1, 2);
1791 void vprint_message(const char* const format, va_list args) CMOCKA_PRINTF_ATTRIBUTE(1, 0);
1792 void vprint_error(const char* const format, va_list args) CMOCKA_PRINTF_ATTRIBUTE(1, 0);
1793 
1796 #endif /* CMOCKA_H_ */
void assert_null(void *pointer)
Assert that the given pointer is NULL.
void expect_any_count(#function,#parameter, size_t count)
Add an event to repeatedly check if a parameter (of any value) has been passed.
void fail(void)
Forces the test to fail immediately and quit.
void expect_not_in_range_count(#function,#parameter, uintmax_t minimum, uintmax_t maximum, size_t count)
Add an event to repeatedly check a parameter is outside a numerical range.
void expect_not_in_range(#function,#parameter, uintmax_t minimum, uintmax_t maximum)
Add an event to check a parameter is outside a numerical range.
void assert_memory_not_equal(const void *a, const void *b, size_t size)
Assert that the two given areas of memory are not equal.
int run_tests(const UnitTest tests[])
Run tests specified by an array of UnitTest structures.
void * mock_ptr_type(#type)
Retrieve a typed return value of the current function.
void expect_check(#function,#parameter,#check_function, const void *check_data)
Add a custom parameter checking function.
void * mock(void)
Retrieve a return value of the current function.
void assert_in_set(uintmax_t value, uintmax_t values[], size_t count)
Assert that the specified value is within a set.
void fail_msg(const char *msg,...)
Forces the test to fail immediately and quit, printing the reason.
void expect_string_count(#function,#parameter, const char *string, size_t count)
Add an event to check if the parameter value is equal to the provided string.
void mock_assert(const int result, const char *const expression, const char *const file, const int line)
Function to replace assert(3) in tested code.
Definition: cmocka.c:1277
void expect_any(#function,#parameter)
Add an event to check if a parameter (of any value) has been passed.
void assert_not_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum)
Assert that the specified value is smaller than the minimum and bigger than the maximum.
void assert_in_range(uintmax_t value, uintmax_t minimum, uintmax_t maximum)
Assert that the specified value is bigger than the minimum and smaller than the maximum.
void expect_string(#function,#parameter, const char *string)
Add an event to check if the parameter value is equal to the provided string.
void will_return_always(#function, void *value)
Store a value that will be always returned by mock().
void assert_not_in_set(uintmax_t value, uintmax_t values[], size_t count)
Assert that the specified value is not within a set.
void expect_not_memory(#function,#parameter, void *memory, size_t size)
Add an event to check if the parameter doesn&#39;t match an area of memory.
void expect_value(#function,#parameter, uintmax_t value)
Add an event to check if a parameter is the given value.
void expect_not_value(#function,#parameter, uintmax_t value)
Add an event to check if a parameter isn&#39;t the given value.
void assert_string_equal(const char *a, const char *b)
Assert that the two given strings are equal.
void * test_malloc(size_t size)
Test function overriding malloc.
void assert_return_code(int rc, int error)
Assert if the return_code is smaller than 0.
void assert_non_null(void *pointer)
Assert that the given pointer is non-NULL.
void expect_not_string(#function,#parameter, const char *string)
Add an event to check if the parameter value isn&#39;t equal to the provided string.
void assert_true(scalar expression)
Assert that the given expression is true.
void expect_not_string_count(#function,#parameter, const char *string, size_t count)
Add an event to check if the parameter value isn&#39;t equal to the provided string.
void assert_string_not_equal(const char *a, const char *b)
Assert that the two given strings are not equal.
void assert_false(scalar expression)
Assert that the given expression is false.
void expect_not_in_set_count(#function,#parameter, uintmax_t value_array[], size_t count)
Add an event to check if the parameter value is not part of the provided array.
void assert_int_not_equal(int a, int b)
Assert that the two given integers are not equal.
void expect_in_range(#function,#parameter, uintmax_t minimum, uintmax_t maximum)
Add an event to check a parameter is inside a numerical range.
int run_test(#function)
Generic method to run a single test.
void will_return_count(#function, void *value, int count)
Store a value to be returned by mock() later.
void expect_not_in_set(#function,#parameter, uintmax_t value_array[])
Add an event to check if the parameter value is not part of the provided array.
void expect_not_value_count(#function,#parameter, uintmax_t value, size_t count)
Add an event to repeatedly check if a parameter isn&#39;t the given value.
void * test_calloc(size_t nmemb, size_t size)
Test function overriding calloc.
void expect_memory(#function,#parameter, void *memory, size_t size)
Add an event to check if the parameter does match an area of memory.
void expect_in_set_count(#function,#parameter, uintmax_t value_array[], size_t count)
Add an event to check if the parameter value is part of the provided array.
void will_return(#function, void *value)
Store a value to be returned by mock() later.
void assert_int_equal(int a, int b)
Assert that the two given integers are equal.
void assert_memory_equal(const void *a, const void *b, size_t size)
Assert that the two given areas of memory are equal, otherwise fail.
void check_expected(#parameter)
Determine whether a function parameter is correct.
void expect_in_range_count(#function,#parameter, uintmax_t minimum, uintmax_t maximum, size_t count)
Add an event to repeatedly check a parameter is inside a numerical range.
void * mock_type(#type)
Retrieve a typed return value of the current function.
void expect_value_count(#function,#parameter, uintmax_t value, size_t count)
Add an event to repeatedly check if a parameter is the given value.
void test_free(void *ptr)
Test function overriding free(3).
void expect_memory_count(#function,#parameter, void *memory, size_t size, size_t count)
Add an event to repeatedly check if the parameter does match an area of memory.
void expect_assert_failure(function fn_call)
Ensure that mock_assert() is called.
void expect_not_memory_count(#function,#parameter, void *memory, size_t size, size_t count)
Add an event to repeatedly check if the parameter doesn&#39;t match an area of memory.
void expect_in_set(#function,#parameter, uintmax_t value_array[])
Add an event to check if the parameter value is part of the provided array.