cut-assertions

cut-assertions

概要

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);

説明

詳細

cut_assert ()

void                cut_assert                          (cut_boolean expression,
                                                         ...);

cut_assert_true ()

void                cut_assert_true                     (cut_boolean expression,
                                                         ...);

0.9から


cut_assert_false ()

void                cut_assert_false                    (cut_boolean expression,
                                                         ...);

0.9から


cut_assert_equal_boolean ()

void                cut_assert_equal_boolean            (cut_boolean expected,
                                                         cut_boolean actual);

1.0.7から


cut_assert_not_equal_boolean ()

void                cut_assert_not_equal_boolean        (cut_boolean expected,
                                                         cut_boolean actual);

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,
                                                         ...);

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);

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);

1.0.7から


cut_assert_equal_size ()

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

1.0.6から


cut_assert_not_equal_size ()

void                cut_assert_not_equal_size           (size_t expected,
                                                         size_t actual);

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);

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);

1.0.7から


cut_assert_equal_string_with_free ()

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

0.3から


cut_assert_equal_string_or_null ()

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

警告

cut_assert_equal_string_or_nullはバージョン0.3から非推奨になりました。新しく書くコードでは使わないでください。代わりにcut_assert_equal_string()を使ってください。


cut_assert_equal_substring ()

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

1.0.7から


cut_assert_not_equal_substring ()

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

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);

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,
                                                         ...);

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, ...)

1.0.5から


cut_assert_operator_size()

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

1.0.5から


cut_assert_operator_double()

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

1.0.5から


cut_assert_equal()

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

cut_assert_errno ()

void                cut_assert_errno                    (...);

0.8から


cut_assert_file_exist ()

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

警告

cut_assert_file_existはバージョン1.0.2から非推奨になりました。新しく書くコードでは使わないでください。代わりにcut_assert_path_exist()を使ってください。

0.9から


cut_assert_path_exist ()

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

1.0.2から


cut_assert_path_not_exist ()

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

1.0.2から


cut_assert_match ()

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

1.0から


cut_assert_match_with_free ()

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

1.0から


cut_assert_equal_pointer ()

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

1.0から


cut_assert_equal_fixture_data_string ()

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

1.0.2から


cut_error ()

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

cut_error_errno ()

void                cut_error_errno                     (...);

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,
                                                         ...);

警告

cut_pendingはバージョン0.4から非推奨になりました。新しく書くコードでは使わないでください。代わりにcut_pend()を使ってください。


cut_notify ()

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

cut_omit ()

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

0.8から


cut_return ()

void                cut_return                          (void);

1.0.6から