| Check
    Unit testing framework for C | 
 
 
 
Go to the documentation of this file.
   30 #include <check_stdint.h> 
   39 #define CK_CPPSTART extern "C" { 
   52 #if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) 
   53 #define GCC_VERSION_AT_LEAST(major, minor, patch) \ 
   54 ((__GNUC__ > (major)) || \ 
   55  (__GNUC__ == (major) && __GNUC_MINOR__ > (minor)) || \ 
   56  (__GNUC__ == (major) && __GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ >= (patch)) ) 
   57 #elif defined(__GNUC__) && defined(__GNUC_MINOR__) 
   58 #define GCC_VERSION_AT_LEAST(major, minor, patch) \ 
   59 ((__GNUC__ > (major)) || \ 
   60  (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor))) 
   62 #define GCC_VERSION_AT_LEAST(major, minor, patch) 0 
   65 #if GCC_VERSION_AT_LEAST(2,95,3) 
   66 #define CK_ATTRIBUTE_UNUSED __attribute__ ((unused)) 
   67 #define CK_ATTRIBUTE_FORMAT(a, b, c) __attribute__ ((format (a, b, c))) 
   69 #define CK_ATTRIBUTE_UNUSED 
   70 #define CK_ATTRIBUTE_FORMAT(a, b, c) 
   73 #if GCC_VERSION_AT_LEAST(2,5,0) 
   74 #define CK_ATTRIBUTE_NORETURN __attribute__ ((noreturn)) 
   76 #define CK_ATTRIBUTE_NORETURN 
   79 #if GCC_VERSION_AT_LEAST(4,7,4) && (__STDC_VERSION__ >= 199901L) 
   81 #define CK_DIAGNOSTIC_STRINGIFY(x) #x 
   82 #define CK_DIAGNOSTIC_HELPER1(y) CK_DIAGNOSTIC_STRINGIFY(GCC diagnostic ignored y) 
   83 #define CK_DIAGNOSTIC_HELPER2(z) CK_DIAGNOSTIC_HELPER1(#z) 
   84 #define CK_DIAGNOSTIC_PUSH_IGNORE(w) \ 
   85     _Pragma("GCC diagnostic push") \ 
   86     _Pragma(CK_DIAGNOSTIC_HELPER2(w)) 
   87 #define CK_DIAGNOSTIC_POP(w) _Pragma ("GCC diagnostic pop") 
   89 #define CK_DIAGNOSTIC_PUSH_IGNORE(w) 
   90 #define CK_DIAGNOSTIC_POP(w) 
   93 #undef GCC_VERSION_AT_LEAST 
   95 #include <sys/types.h> 
  128 #define CHECK_MAJOR_VERSION (0) 
  129 #define CHECK_MINOR_VERSION (15) 
  130 #define CHECK_MICRO_VERSION (2) 
  132 CK_DLL_EXP 
extern int CK_EXPORT check_major_version;
 
  133 CK_DLL_EXP 
extern int CK_EXPORT check_minor_version;
 
  134 CK_DLL_EXP 
extern int CK_EXPORT check_micro_version;
 
  137 #define NULL ((void*)0) 
  253 #define tcase_add_test(tc,tf) tcase_add_test_raise_signal(tc,tf,0) 
  267 #define tcase_add_test_raise_signal(tc,ttest,signal) \ 
  268    _tcase_add_test((tc),(ttest),(signal), 0, 0, 1) 
  282 #define tcase_add_exit_test(tc, ttest, expected_exit_value) \ 
  283   _tcase_add_test((tc),(ttest),0,(expected_exit_value),0,1) 
  299 #define tcase_add_loop_test(tc,ttest,s,e) \ 
  300   _tcase_add_test((tc),(ttest),0,0,(s),(e)) 
  320 #define tcase_add_loop_test_raise_signal(tc,ttest,signal,s,e) \ 
  321   _tcase_add_test((tc),(ttest),(signal),0,(s),(e)) 
  341 #define tcase_add_loop_exit_test(tc,ttest,expected_exit_value,s,e) \ 
  342   _tcase_add_test((tc),(ttest),0,(expected_exit_value),(s),(e)) 
  347 CK_DLL_EXP 
void CK_EXPORT _tcase_add_test(
TCase * tc, 
const TTest * ttest,
 
  348                                           int _signal, 
int allowed_exit_value,
 
  451 #define START_TEST(__testname)\ 
  452 static void __testname ## _fn (int _i CK_ATTRIBUTE_UNUSED);\ 
  453 static const TTest __testname ## _ttest = {""# __testname, __testname ## _fn, __FILE__, __LINE__};\ 
  454 static const TTest * __testname = & __testname ## _ttest;\ 
  455 static void __testname ## _fn (int _i CK_ATTRIBUTE_UNUSED) 
  469 #define fail_unless(expr, ...) \ 
  471     _mark_point(__FILE__, __LINE__) : \ 
  472     _ck_assert_failed(__FILE__, __LINE__, "Assertion '"#expr"' failed" , ## __VA_ARGS__, NULL) 
  484 #define fail_if(expr, ...)\ 
  486      _ck_assert_failed(__FILE__, __LINE__, "Failure '"#expr"' occurred" , ## __VA_ARGS__, NULL) \ 
  487      : _mark_point(__FILE__, __LINE__) 
  494 #define fail(...) _ck_assert_failed(__FILE__, __LINE__, "Failed" , ## __VA_ARGS__, NULL) 
  505 CK_DLL_EXP 
void CK_EXPORT _ck_assert_failed(
const char *file, 
int line,
 
  506                                             const char *expr, 
const char *msg,
 
  507                                             ...) CK_ATTRIBUTE_NORETURN CK_ATTRIBUTE_FORMAT(printf, 4, 5);
 
  509 CK_DLL_EXP 
void CK_EXPORT _ck_assert_failed(
const char *file, 
int line,
 
  510                                             const char *expr, 
const char *msg,
 
  511                                             ...) CK_ATTRIBUTE_FORMAT(printf, 4, 5);
 
  523 #define ck_assert(expr) ck_assert_msg(expr, NULL) 
  538 #define ck_assert_msg(expr, ...) \ 
  540      _mark_point(__FILE__, __LINE__) : \ 
  541      _ck_assert_failed(__FILE__, __LINE__, "Assertion '"#expr"' failed" , ## __VA_ARGS__) 
  550 #define ck_abort() ck_abort_msg(NULL) 
  560 #define ck_abort_msg(...) _ck_assert_failed(__FILE__, __LINE__, "Failed" , ## __VA_ARGS__) 
  564 #define _ck_assert_int(X, OP, Y) do { \ 
  565   intmax_t _ck_x = (X); \ 
  566   intmax_t _ck_y = (Y); \ 
  567   ck_assert_msg(_ck_x OP _ck_y, "Assertion '%s' failed: %s == %jd, %s == %jd", #X" "#OP" "#Y, #X, _ck_x, #Y, _ck_y); \ 
  582 #define ck_assert_int_eq(X, Y) _ck_assert_int(X, ==, Y) 
  595 #define ck_assert_int_ne(X, Y) _ck_assert_int(X, !=, Y) 
  608 #define ck_assert_int_lt(X, Y) _ck_assert_int(X, <, Y) 
  621 #define ck_assert_int_le(X, Y) _ck_assert_int(X, <=, Y) 
  634 #define ck_assert_int_gt(X, Y) _ck_assert_int(X, >, Y) 
  647 #define ck_assert_int_ge(X, Y) _ck_assert_int(X, >=, Y) 
  649 #define _ck_assert_uint(X, OP, Y) do { \ 
  650   uintmax_t _ck_x = (X); \ 
  651   uintmax_t _ck_y = (Y); \ 
  652   ck_assert_msg(_ck_x OP _ck_y, "Assertion '%s' failed: %s == %ju, %s == %ju", #X" "#OP" "#Y, #X, _ck_x, #Y, _ck_y); \ 
  666 #define ck_assert_uint_eq(X, Y) _ck_assert_uint(X, ==, Y) 
  679 #define ck_assert_uint_ne(X, Y) _ck_assert_uint(X, !=, Y) 
  692 #define ck_assert_uint_lt(X, Y) _ck_assert_uint(X, <, Y) 
  705 #define ck_assert_uint_le(X, Y) _ck_assert_uint(X, <=, Y) 
  718 #define ck_assert_uint_gt(X, Y) _ck_assert_uint(X, >, Y) 
  731 #define ck_assert_uint_ge(X, Y) _ck_assert_uint(X, >=, Y) 
  734 #ifndef CK_FLOATING_DIG 
  735 # define CK_FLOATING_DIG 6 
  741 #define _ck_assert_floating(X, OP, Y, TP, TM) do { \ 
  744   ck_assert_msg(_ck_x OP _ck_y, \ 
  745   "Assertion '%s' failed: %s == %.*" TM "g, %s == %.*" TM "g", \ 
  747   #X, (int)CK_FLOATING_DIG, _ck_x, \ 
  748   #Y, (int)CK_FLOATING_DIG, _ck_y); \ 
  753 #define _ck_assert_floating_finite(X, TP, TM) \ 
  756   ck_assert_msg(isfinite(_ck_x), \ 
  757     "Assertion '%s' failed: %s == %.*" TM "g", \ 
  759     #X, (int)CK_FLOATING_DIG, _ck_x); \ 
  764 #define _ck_assert_floating_infinite(X, TP, TM) \ 
  767   ck_assert_msg(isinf(_ck_x), \ 
  768     "Assertion '%s' failed: %s == %.*" TM "g", \ 
  770     #X, (int)CK_FLOATING_DIG, _ck_x); \ 
  775 #define _ck_assert_floating_nan(X, TP, TM) \ 
  778   ck_assert_msg(isnan(_ck_x), \ 
  779     "Assertion '%s' failed: %s == %.*" TM "g", \ 
  781     #X, (int)CK_FLOATING_DIG, _ck_x); \ 
  786 #define _ck_assert_floating_nonnan(X, TP, TM) \ 
  789   ck_assert_msg(!isnan(_ck_x), \ 
  790     "Assertion '%s' failed: %s == %.*" TM "g", \ 
  792     #X, (int)CK_FLOATING_DIG, _ck_x); \ 
  798 #define _ck_assert_floating_op_tol(X, OP, Y, T, D, TP, TM) do { \ 
  802   ck_assert_msg((_ck_x - _ck_y) OP _ck_t * (D), \ 
  803   "Assertion '%s' failed: %s == %.*" TM "g, %s == %.*" TM "g, %s == %.*" TM "g", \ 
  804   #X" "#OP"= "#Y", error < "#T, \ 
  805   #X, (int)CK_FLOATING_DIG, _ck_x, \ 
  806   #Y, (int)CK_FLOATING_DIG, _ck_y, \ 
  807   #T, (int)CK_FLOATING_DIG, _ck_t); \ 
  813 #define _ck_assert_floating_absdiff_op_tol(X, Y, OP, T, TP, TM) \ 
  818   ck_assert_msg(fabsl(_ck_y - _ck_x) OP _ck_t, \ 
  819     "Assertion '%s' failed: %s == %.*" TM "g, %s == %.*" TM "g, %s == %.*" TM "g", \ 
  820     "fabsl("#Y" - "#X") "#OP" "#T, \ 
  821     #X, (int)CK_FLOATING_DIG, _ck_x, \ 
  822     #Y, (int)CK_FLOATING_DIG, _ck_y, \ 
  823     #T, (int)CK_FLOATING_DIG, _ck_t); \ 
  842 #define ck_assert_float_eq(X, Y) _ck_assert_floating(X, ==, Y, float, "") 
  859 #define ck_assert_float_ne(X, Y) _ck_assert_floating(X, !=, Y, float, "") 
  872 #define ck_assert_float_lt(X, Y) _ck_assert_floating(X, <, Y, float, "") 
  885 #define ck_assert_float_le(X, Y) _ck_assert_floating(X, <=, Y, float, "") 
  898 #define ck_assert_float_gt(X, Y) _ck_assert_floating(X, >, Y, float, "") 
  911 #define ck_assert_float_ge(X, Y) _ck_assert_floating(X, >=, Y, float, "") 
  927 #define ck_assert_float_eq_tol(X, Y, T)  _ck_assert_floating_absdiff_op_tol(X, Y, <, T, float, "") 
  943 #define ck_assert_float_ne_tol(X, Y, T) _ck_assert_floating_absdiff_op_tol(X, Y, >=, T, float, "") 
  959 #define ck_assert_float_ge_tol(X, Y, T) _ck_assert_floating_op_tol(X, >, Y, T, -1, float, "") 
  975 #define ck_assert_float_le_tol(X, Y, T) _ck_assert_floating_op_tol(X, <, Y, T, 1, float, "") 
  989 #define ck_assert_float_finite(X) _ck_assert_floating_finite(X, float, "") 
 1003 #define ck_assert_float_infinite(X) _ck_assert_floating_infinite(X, float, "") 
 1017 #define ck_assert_float_nan(X) _ck_assert_floating_nan(X, float, "") 
 1031 #define ck_assert_float_nonnan(X) _ck_assert_floating_nonnan(X, float, "") 
 1049 #define ck_assert_double_eq(X, Y) _ck_assert_floating(X, ==, Y, double, "") 
 1066 #define ck_assert_double_ne(X, Y) _ck_assert_floating(X, !=, Y, double, "") 
 1079 #define ck_assert_double_lt(X, Y) _ck_assert_floating(X, <, Y, double, "") 
 1092 #define ck_assert_double_le(X, Y) _ck_assert_floating(X, <=, Y, double, "") 
 1105 #define ck_assert_double_gt(X, Y) _ck_assert_floating(X, >, Y, double, "") 
 1118 #define ck_assert_double_ge(X, Y) _ck_assert_floating(X, >=, Y, double, "") 
 1134 #define ck_assert_double_eq_tol(X, Y, T)  _ck_assert_floating_absdiff_op_tol(X, Y, <, T, double, "") 
 1150 #define ck_assert_double_ne_tol(X, Y, T) _ck_assert_floating_absdiff_op_tol(X, Y, >=, T, double, "") 
 1166 #define ck_assert_double_ge_tol(X, Y, T) _ck_assert_floating_op_tol(X, >, Y, T, -1, double, "") 
 1182 #define ck_assert_double_le_tol(X, Y, T) _ck_assert_floating_op_tol(X, <, Y, T, 1, double, "") 
 1196 #define ck_assert_double_finite(X) _ck_assert_floating_finite(X, double, "") 
 1210 #define ck_assert_double_infinite(X) _ck_assert_floating_infinite(X, double, "") 
 1224 #define ck_assert_double_nan(X) _ck_assert_floating_nan(X, double, "") 
 1238 #define ck_assert_double_nonnan(X) _ck_assert_floating_nonnan(X, double, "") 
 1256 #define ck_assert_ldouble_eq(X, Y) _ck_assert_floating(X, ==, Y, long double, "L") 
 1273 #define ck_assert_ldouble_ne(X, Y) _ck_assert_floating(X, !=, Y, long double, "L") 
 1286 #define ck_assert_ldouble_lt(X, Y) _ck_assert_floating(X, <, Y, long double, "L") 
 1299 #define ck_assert_ldouble_le(X, Y) _ck_assert_floating(X, <=, Y, long double, "L") 
 1312 #define ck_assert_ldouble_gt(X, Y) _ck_assert_floating(X, >, Y, long double, "L") 
 1325 #define ck_assert_ldouble_ge(X, Y) _ck_assert_floating(X, >=, Y, long double, "L") 
 1341 #define ck_assert_ldouble_eq_tol(X, Y, T)  _ck_assert_floating_absdiff_op_tol(X, Y, <, T, long double, "L") 
 1357 #define ck_assert_ldouble_ne_tol(X, Y, T) _ck_assert_floating_absdiff_op_tol(X, Y, >=, T, long double, "L") 
 1373 #define ck_assert_ldouble_ge_tol(X, Y, T) _ck_assert_floating_op_tol(X, >, Y, T, -1, long double, "L") 
 1389 #define ck_assert_ldouble_le_tol(X, Y, T) _ck_assert_floating_op_tol(X, <, Y, T, 1, long double, "L") 
 1403 #define ck_assert_ldouble_finite(X) _ck_assert_floating_finite(X, long double, "L") 
 1417 #define ck_assert_ldouble_infinite(X) _ck_assert_floating_infinite(X, long double, "L") 
 1431 #define ck_assert_ldouble_nan(X) _ck_assert_floating_nan(X, long double, "L") 
 1445 #define ck_assert_ldouble_nonnan(X) _ck_assert_floating_nonnan(X, long double, "L") 
 1452 #define _ck_assert_str(X, OP, Y, NULLEQ, NULLNE) do { \ 
 1453   const char* _ck_x = (X); \ 
 1454   const char* _ck_y = (Y); \ 
 1455   const char* _ck_x_s; \ 
 1456   const char* _ck_y_s; \ 
 1457   const char* _ck_x_q; \ 
 1458   const char* _ck_y_q; \ 
 1459   if (_ck_x != NULL) { \ 
 1464     _ck_x_s = "(null)"; \ 
 1466   if (_ck_y != NULL) { \ 
 1471     _ck_y_s = "(null)"; \ 
 1474     (NULLEQ && (_ck_x == NULL) && (_ck_y == NULL)) || \ 
 1475     (NULLNE && ((_ck_x == NULL) || (_ck_y == NULL)) && (_ck_x != _ck_y)) || \ 
 1476     ((_ck_x != NULL) && (_ck_y != NULL) && (0 OP strcmp(_ck_y, _ck_x))), \ 
 1477     "Assertion '%s' failed: %s == %s%s%s, %s == %s%s%s", \ 
 1479     #X, _ck_x_q, _ck_x_s, _ck_x_q, \ 
 1480     #Y, _ck_y_q, _ck_y_s, _ck_y_q); \ 
 1496 #define ck_assert_str_eq(X, Y) _ck_assert_str(X, ==, Y, 0, 0) 
 1511 #define ck_assert_str_ne(X, Y) _ck_assert_str(X, !=, Y, 0, 0) 
 1526 #define ck_assert_str_lt(X, Y) _ck_assert_str(X, <, Y, 0, 0) 
 1541 #define ck_assert_str_le(X, Y) _ck_assert_str(X, <=, Y, 0, 0) 
 1556 #define ck_assert_str_gt(X, Y) _ck_assert_str(X, >, Y, 0, 0) 
 1571 #define ck_assert_str_ge(X, Y) _ck_assert_str(X, >=, Y, 0, 0) 
 1587 #define ck_assert_pstr_eq(X, Y) _ck_assert_str(X, ==, Y, 1, 0) 
 1603 #define ck_assert_pstr_ne(X, Y) _ck_assert_str(X, !=, Y, 0, 1) 
 1609 #ifndef CK_MAX_ASSERT_MEM_PRINT_SIZE 
 1610 #define CK_MAX_ASSERT_MEM_PRINT_SIZE 64 
 1617 #ifndef CK_MAX_ASSERT_MEM_PRINT_SIZE 
 1618 #define CK_MAX_ASSERT_MEM_PRINT_SIZE 64 
 1621 #define _ck_assert_mem(X, OP, Y, L) do { \ 
 1622   const uint8_t* _ck_x = (const uint8_t*)(X); \ 
 1623   const uint8_t* _ck_y = (const uint8_t*)(Y); \ 
 1624   size_t _ck_l = (L); \ 
 1625   char _ck_x_str[CK_MAX_ASSERT_MEM_PRINT_SIZE * 2 + 1]; \ 
 1626   char _ck_y_str[CK_MAX_ASSERT_MEM_PRINT_SIZE * 2 + 1]; \ 
 1627   static const char _ck_hexdigits[] = "0123456789abcdef"; \ 
 1629   size_t _ck_maxl = (_ck_l > CK_MAX_ASSERT_MEM_PRINT_SIZE) ? CK_MAX_ASSERT_MEM_PRINT_SIZE : _ck_l; \ 
 1630   for (_ck_i = 0; _ck_i < _ck_maxl; _ck_i++) { \ 
 1631     _ck_x_str[_ck_i * 2  ]   = _ck_hexdigits[(_ck_x[_ck_i] >> 4) & 0xF]; \ 
 1632     _ck_y_str[_ck_i * 2  ]   = _ck_hexdigits[(_ck_y[_ck_i] >> 4) & 0xF]; \ 
 1633     _ck_x_str[_ck_i * 2 + 1] = _ck_hexdigits[_ck_x[_ck_i] & 0xF]; \ 
 1634     _ck_y_str[_ck_i * 2 + 1] = _ck_hexdigits[_ck_y[_ck_i] & 0xF]; \ 
 1636   _ck_x_str[_ck_i * 2] = 0; \ 
 1637   _ck_y_str[_ck_i * 2] = 0; \ 
 1638   if (_ck_maxl != _ck_l) { \ 
 1639     _ck_x_str[_ck_i * 2 - 2] = '.'; \ 
 1640     _ck_y_str[_ck_i * 2 - 2] = '.'; \ 
 1641     _ck_x_str[_ck_i * 2 - 1] = '.'; \ 
 1642     _ck_y_str[_ck_i * 2 - 1] = '.'; \ 
 1644   ck_assert_msg(0 OP memcmp(_ck_y, _ck_x, _ck_l), \ 
 1645     "Assertion '%s' failed: %s == \"%s\", %s == \"%s\"", #X" "#OP" "#Y, #X, _ck_x_str, #Y, _ck_y_str); \ 
 1659 #define ck_assert_mem_eq(X, Y, L) _ck_assert_mem(X, ==, Y, L) 
 1672 #define ck_assert_mem_ne(X, Y, L) _ck_assert_mem(X, !=, Y, L) 
 1685 #define ck_assert_mem_lt(X, Y, L) _ck_assert_mem(X, <, Y, L) 
 1698 #define ck_assert_mem_le(X, Y, L) _ck_assert_mem(X, <=, Y, L) 
 1711 #define ck_assert_mem_gt(X, Y, L) _ck_assert_mem(X, >, Y, L) 
 1724 #define ck_assert_mem_ge(X, Y, L) _ck_assert_mem(X, >=, Y, L) 
 1728 #define _ck_assert_ptr(X, OP, Y) do { \ 
 1729   const void* _ck_x = (X); \ 
 1730   const void* _ck_y = (Y); \ 
 1731   ck_assert_msg(_ck_x OP _ck_y, "Assertion '%s' failed: %s == %#lx, %s == %#lx", #X" "#OP" "#Y, #X, (unsigned long)(uintptr_t)_ck_x, #Y, (unsigned long)(uintptr_t)_ck_y); \ 
 1737 #define _ck_assert_ptr_null(X, OP) do { \ 
 1738   const void* _ck_x = (X); \ 
 1739   ck_assert_msg(_ck_x OP NULL, \ 
 1740   "Assertion '%s' failed: %s == %#lx", \ 
 1742   #X, (unsigned long)(uintptr_t)_ck_x); \ 
 1758 #define ck_assert_ptr_eq(X, Y) _ck_assert_ptr(X, ==, Y) 
 1770 #define ck_assert_ptr_ne(X, Y) _ck_assert_ptr(X, !=, Y) 
 1783 #define ck_assert_ptr_null(X) _ck_assert_ptr_null(X, ==) 
 1796 #define ck_assert_ptr_nonnull(X) _ck_assert_ptr_null(X, !=) 
 1808 #define mark_point() _mark_point(__FILE__,__LINE__) 
 1811 CK_DLL_EXP 
void CK_EXPORT _mark_point(
const char *file, 
int line);
 
 2065                                              const char *include_tags,
 
 2066                                              const char *exclude_tags,
 
  
fork_status
Definition: check.h:2268
@ CK_LAST
Definition: check.h:1842
CK_DLL_EXP pid_t CK_EXPORT check_fork(void)
CK_DLL_EXP const char *CK_EXPORT srunner_tap_fname(SRunner *sr)
TFun fn
Definition: check.h:169
CK_DLL_EXP const char *CK_EXPORT tcase_name(void)
CK_DLL_EXP void CK_EXPORT srunner_set_fork_status(SRunner *sr, enum fork_status fstat)
print_output
Definition: check.h:1829
@ CK_ENV
Definition: check.h:1834
@ CK_VERBOSE
Definition: check.h:1833
CK_DLL_EXP void CK_EXPORT suite_add_tcase(Suite *s, TCase *tc)
@ CK_SILENT
Definition: check.h:1830
CK_DLL_EXP const char *CK_EXPORT tr_msg(TestResult *tr)
@ CK_PASS
Definition: check.h:1819
CK_DLL_EXP void CK_EXPORT check_set_max_msg_size(size_t max_msg_size)
CK_DLL_EXP int CK_EXPORT suite_tcase(Suite *s, const char *tcname)
CK_DLL_EXP int CK_EXPORT tr_rtype(TestResult *tr)
CK_DLL_EXP int CK_EXPORT tr_lno(TestResult *tr)
void(* SFun)(void)
Definition: check.h:157
test_result
Definition: check.h:1817
CK_DLL_EXP const char *CK_EXPORT srunner_log_fname(SRunner *sr)
CK_DLL_EXP void CK_EXPORT srunner_run(SRunner *sr, const char *sname, const char *tcname, enum print_output print_mode)
CK_DLL_EXP void CK_EXPORT srunner_run_tagged(SRunner *sr, const char *sname, const char *tcname, const char *include_tags, const char *exclude_tags, enum print_output print_mode)
CK_DLL_EXP void CK_EXPORT srunner_set_log(SRunner *sr, const char *fname)
CK_DLL_EXP int CK_EXPORT srunner_ntests_failed(SRunner *sr)
CK_DLL_EXP Suite *CK_EXPORT suite_create(const char *name)
@ CK_CTX_TEST
Definition: check.h:1862
@ CK_FORK
Definition: check.h:2270
@ CK_FAILURE
Definition: check.h:1820
CK_DLL_EXP int CK_EXPORT srunner_ntests_run(SRunner *sr)
const char * file
Definition: check.h:170
@ CK_NORMAL
Definition: check.h:1832
CK_DLL_EXP const char *CK_EXPORT tr_lfile(TestResult *tr)
@ CK_CTX_SETUP
Definition: check.h:1861
CK_DLL_EXP void CK_EXPORT srunner_print(SRunner *sr, enum print_output print_mode)
CK_DLL_EXP void CK_EXPORT check_waitpid_and_exit(pid_t pid) CK_ATTRIBUTE_NORETURN
struct SRunner SRunner
Definition: check.h:1848
CK_DLL_EXP TestResult **CK_EXPORT srunner_results(SRunner *sr)
struct TCase TCase
Definition: check.h:147
struct Suite Suite
Definition: check.h:162
CK_DLL_EXP const char *CK_EXPORT srunner_xml_fname(SRunner *sr)
CK_DLL_EXP enum fork_status CK_EXPORT srunner_fork_status(SRunner *sr)
CK_DLL_EXP void CK_EXPORT tcase_add_checked_fixture(TCase *tc, SFun setup, SFun teardown)
@ CK_FORK_GETENV
Definition: check.h:2269
CK_DLL_EXP void CK_EXPORT srunner_free(SRunner *sr)
@ CK_TEST_RESULT_INVALID
Definition: check.h:1818
CK_DLL_EXP void CK_EXPORT srunner_add_suite(SRunner *sr, Suite *s)
CK_DLL_EXP const char *CK_EXPORT tr_tcname(TestResult *tr)
CK_DLL_EXP void CK_EXPORT srunner_set_xml(SRunner *sr, const char *fname)
int line
Definition: check.h:171
CK_DLL_EXP int CK_EXPORT srunner_has_tap(SRunner *sr)
@ CK_NOFORK
Definition: check.h:2271
CK_DLL_EXP void CK_EXPORT srunner_set_tap(SRunner *sr, const char *fname)
@ CK_CTX_TEARDOWN
Definition: check.h:1863
ck_result_ctx
Definition: check.h:1859
@ CK_CTX_INVALID
Definition: check.h:1860
CK_DLL_EXP void CK_EXPORT tcase_fn_start(const char *fname, const char *file, int line)
CK_DLL_EXP TCase *CK_EXPORT tcase_create(const char *name)
CK_DLL_EXP int CK_EXPORT srunner_has_log(SRunner *sr)
CK_DLL_EXP enum ck_result_ctx CK_EXPORT tr_ctx(TestResult *tr)
CK_DLL_EXP SRunner *CK_EXPORT srunner_create(Suite *s)
CK_DLL_EXP void CK_EXPORT tcase_add_unchecked_fixture(TCase *tc, SFun setup, SFun teardown)
CK_DLL_EXP TestResult **CK_EXPORT srunner_failures(SRunner *sr)
CK_DLL_EXP int CK_EXPORT srunner_has_xml(SRunner *sr)
const char * name
Definition: check.h:168
@ CK_ERROR
Definition: check.h:1821
@ CK_MINIMAL
Definition: check.h:1831
CK_DLL_EXP void CK_EXPORT tcase_set_timeout(TCase *tc, double timeout)
CK_DLL_EXP void CK_EXPORT srunner_run_all(SRunner *sr, enum print_output print_mode)
struct TestResult TestResult
Definition: check.h:1853
CK_DLL_EXP void CK_EXPORT tcase_set_tags(TCase *tc, const char *tags)
void(* TFun)(int)
Definition: check.h:152