cut-assertions

cut-assertions

Synopsis

void                cut_assert                          (cut_boolean expression,
                                                         ...);
void                cut_assert_true                     (cut_boolean expression,
                                                         ...);
void                cut_assert_false                    (cut_boolean expression,
                                                         ...);
void                cut_assert_equal_boolean            (cut_boolean expected,
                                                         cut_boolean actual);
void                cut_assert_not_equal_boolean        (cut_boolean expected,
                                                         cut_boolean actual);
void                cut_assert_null                     (const void *expression,
                                                         ...);
void                cut_assert_null_string              (const char *string,
                                                         ...);
void                cut_assert_not_null                 (const void *expression,
                                                         ...);
void                cut_assert_equal_int                (int expected,
                                                         int actual,
                                                         ...);
void                cut_assert_not_equal_int            (int expected,
                                                         int actual);
void                cut_assert_equal_uint               (unsigned int expected,
                                                         unsigned int actual,
                                                         ...);
void                cut_assert_not_equal_uint           (unsigned int expected,
                                                         unsigned int actual);
void                cut_assert_equal_size               (size_t expected,
                                                         size_t actual,
                                                         ...);
void                cut_assert_not_equal_size           (size_t expected,
                                                         size_t actual);
void                cut_assert_equal_double             (double expected,
                                                         double error,
                                                         double actual,
                                                         ...);
void                cut_assert_not_equal_double         (double expected,
                                                         double error,
                                                         double actual);
void                cut_assert_equal_string             (const char *expected,
                                                         const char *actual,
                                                         ...);
void                cut_assert_not_equal_string         (const char *expected,
                                                         const char *actual);
void                cut_assert_equal_string_with_free   (const char *expected,
                                                         const char *actual,
                                                         ...);
void                cut_assert_equal_string_or_null     (const char *expected,
                                                         const char *actual,
                                                         ...);
void                cut_assert_equal_substring          (const char *expected,
                                                         const char *actual,
                                                         size_t length);
void                cut_assert_not_equal_substring      (const char *expected,
                                                         const char *actual,
                                                         size_t length);
void                cut_assert_equal_memory             (const void *expected,
                                                         size_t expected_size,
                                                         const void *actual,
                                                         size_t actual_size,
                                                         ...);
void                cut_assert_not_equal_memory         (const void *expected,
                                                         size_t expected_size,
                                                         const void *actual,
                                                         size_t actual_size);
void                cut_assert_equal_string_array       (char **expected,
                                                         char **actual,
                                                         ...);
void                cut_assert_equal_string_array_with_free
                                                        (char **expected,
                                                         char **actual,
                                                         ...);
#define             cut_assert_operator                 (lhs, operator, rhs, ...)
#define             cut_assert_operator_int             (lhs, operator, rhs, ...)
#define             cut_assert_operator_uint            (lhs, operator, rhs, ...)
#define             cut_assert_operator_size            (lhs, operator, rhs, ...)
#define             cut_assert_operator_double          (lhs, operator, rhs, ...)
#define             cut_assert_equal                    (function, expected, actual, ...)
void                cut_assert_errno                    (...);
void                cut_assert_file_exist               (const char *path,
                                                         ...);
void                cut_assert_path_exist               (const char *path,
                                                         ...);
void                cut_assert_path_not_exist           (const char *path,
                                                         ...);
void                cut_assert_match                    (const char *pattern,
                                                         const char *actual,
                                                         ...);
void                cut_assert_match_with_free          (const char *pattern,
                                                         const char *actual,
                                                         ...);
void                cut_assert_equal_pointer            (const void *expected,
                                                         const void *actual,
                                                         ...);
void                cut_assert_equal_fixture_data_string
                                                        (const char *expected,
                                                         const void *path,
                                                         ...);
void                cut_error                           (const char *format,
                                                         ...);
void                cut_error_errno                     (...);
void                cut_fail                            (const char *format,
                                                         ...);
void                cut_pend                            (const char *format,
                                                         ...);
void                cut_pending                         (const char *format,
                                                         ...);
void                cut_notify                          (const char *format,
                                                         ...);
void                cut_omit                            (const char *format,
                                                         ...);
void                cut_return                          (void);

Description

Details

cut_assert ()

void                cut_assert                          (cut_boolean expression,
                                                         ...);

cut_assert_true ()

void                cut_assert_true                     (cut_boolean expression,
                                                         ...);

Since 0.9


cut_assert_false ()

void                cut_assert_false                    (cut_boolean expression,
                                                         ...);

Since 0.9


cut_assert_equal_boolean ()

void                cut_assert_equal_boolean            (cut_boolean expected,
                                                         cut_boolean actual);

Since 1.0.7


cut_assert_not_equal_boolean ()

void                cut_assert_not_equal_boolean        (cut_boolean expected,
                                                         cut_boolean actual);

Since 1.0.7


cut_assert_null ()

void                cut_assert_null                     (const void *expression,
                                                         ...);

cut_assert_null_string ()

void                cut_assert_null_string              (const char *string,
                                                         ...);

Since 0.3


cut_assert_not_null ()

void                cut_assert_not_null                 (const void *expression,
                                                         ...);

cut_assert_equal_int ()

void                cut_assert_equal_int                (int expected,
                                                         int actual,
                                                         ...);

cut_assert_not_equal_int ()

void                cut_assert_not_equal_int            (int expected,
                                                         int actual);

Since 1.0.7


cut_assert_equal_uint ()

void                cut_assert_equal_uint               (unsigned int expected,
                                                         unsigned int actual,
                                                         ...);

cut_assert_not_equal_uint ()

void                cut_assert_not_equal_uint           (unsigned int expected,
                                                         unsigned int actual);

Since 1.0.7


cut_assert_equal_size ()

void                cut_assert_equal_size               (size_t expected,
                                                         size_t actual,
                                                         ...);

Since 1.0.6


cut_assert_not_equal_size ()

void                cut_assert_not_equal_size           (size_t expected,
                                                         size_t actual);

Since 1.0.7


cut_assert_equal_double ()

void                cut_assert_equal_double             (double expected,
                                                         double error,
                                                         double actual,
                                                         ...);

cut_assert_not_equal_double ()

void                cut_assert_not_equal_double         (double expected,
                                                         double error,
                                                         double actual);

Since 1.0.7


cut_assert_equal_string ()

void                cut_assert_equal_string             (const char *expected,
                                                         const char *actual,
                                                         ...);

cut_assert_not_equal_string ()

void                cut_assert_not_equal_string         (const char *expected,
                                                         const char *actual);

Since 1.0.7


cut_assert_equal_string_with_free ()

void                cut_assert_equal_string_with_free   (const char *expected,
                                                         const char *actual,
                                                         ...);

Since 0.3


cut_assert_equal_string_or_null ()

void                cut_assert_equal_string_or_null     (const char *expected,
                                                         const char *actual,
                                                         ...);

Warning

cut_assert_equal_string_or_null has been deprecated since version 0.3 and should not be used in newly-written code. Use cut_assert_equal_string() instead.


cut_assert_equal_substring ()

void                cut_assert_equal_substring          (const char *expected,
                                                         const char *actual,
                                                         size_t length);

Since 1.0.7


cut_assert_not_equal_substring ()

void                cut_assert_not_equal_substring      (const char *expected,
                                                         const char *actual,
                                                         size_t length);

Since 1.0.7


cut_assert_equal_memory ()

void                cut_assert_equal_memory             (const void *expected,
                                                         size_t expected_size,
                                                         const void *actual,
                                                         size_t actual_size,
                                                         ...);

cut_assert_not_equal_memory ()

void                cut_assert_not_equal_memory         (const void *expected,
                                                         size_t expected_size,
                                                         const void *actual,
                                                         size_t actual_size);

Since 1.0.7


cut_assert_equal_string_array ()

void                cut_assert_equal_string_array       (char **expected,
                                                         char **actual,
                                                         ...);

cut_assert_equal_string_array_with_free ()

void                cut_assert_equal_string_array_with_free
                                                        (char **expected,
                                                         char **actual,
                                                         ...);

Since 0.9


cut_assert_operator()

#define             cut_assert_operator(lhs, operator, rhs, ...)

cut_assert_operator_int()

#define             cut_assert_operator_int(lhs, operator, rhs, ...)

cut_assert_operator_uint()

#define             cut_assert_operator_uint(lhs, operator, rhs, ...)

Since 1.0.5


cut_assert_operator_size()

#define             cut_assert_operator_size(lhs, operator, rhs, ...)

Since 1.0.5


cut_assert_operator_double()

#define             cut_assert_operator_double(lhs, operator, rhs, ...)

Since 1.0.5


cut_assert_equal()

#define             cut_assert_equal(function, expected, actual, ...)

cut_assert_errno ()

void                cut_assert_errno                    (...);

Since 0.8


cut_assert_file_exist ()

void                cut_assert_file_exist               (const char *path,
                                                         ...);

Warning

cut_assert_file_exist has been deprecated since version 1.0.2 and should not be used in newly-written code. Use cut_assert_path_exist() instead.

Since 0.9


cut_assert_path_exist ()

void                cut_assert_path_exist               (const char *path,
                                                         ...);

Since 1.0.2


cut_assert_path_not_exist ()

void                cut_assert_path_not_exist           (const char *path,
                                                         ...);

Since 1.0.2


cut_assert_match ()

void                cut_assert_match                    (const char *pattern,
                                                         const char *actual,
                                                         ...);

Since 1.0


cut_assert_match_with_free ()

void                cut_assert_match_with_free          (const char *pattern,
                                                         const char *actual,
                                                         ...);

Since 1.0


cut_assert_equal_pointer ()

void                cut_assert_equal_pointer            (const void *expected,
                                                         const void *actual,
                                                         ...);

Since 1.0


cut_assert_equal_fixture_data_string ()

void                cut_assert_equal_fixture_data_string
                                                        (const char *expected,
                                                         const void *path,
                                                         ...);

Since 1.0.2


cut_error ()

void                cut_error                           (const char *format,
                                                         ...);

cut_error_errno ()

void                cut_error_errno                     (...);

Since 1.0.2


cut_fail ()

void                cut_fail                            (const char *format,
                                                         ...);

cut_pend ()

void                cut_pend                            (const char *format,
                                                         ...);

cut_pending ()

void                cut_pending                         (const char *format,
                                                         ...);

Warning

cut_pending has been deprecated since version 0.4 and should not be used in newly-written code. Use cut_pend() instead.


cut_notify ()

void                cut_notify                          (const char *format,
                                                         ...);

cut_omit ()

void                cut_omit                            (const char *format,
                                                         ...);

Since 0.8


cut_return ()

void                cut_return                          (void);

Since 1.0.6