ATF-C-API(3) | Library Functions Manual | ATF-C-API(3) |
atf-c-api
, ATF_CHECK
,
ATF_CHECK_MSG
, ATF_CHECK_EQ
,
ATF_CHECK_EQ_MSG
,
ATF_CHECK_MATCH
,
ATF_CHECK_MATCH_MSG
,
ATF_CHECK_STREQ
,
ATF_CHECK_STREQ_MSG
,
ATF_CHECK_ERRNO
, ATF_REQUIRE
,
ATF_REQUIRE_MSG
,
ATF_REQUIRE_EQ
,
ATF_REQUIRE_EQ_MSG
,
ATF_REQUIRE_MATCH
,
ATF_REQUIRE_MATCH_MSG
,
ATF_REQUIRE_STREQ
,
ATF_REQUIRE_STREQ_MSG
,
ATF_REQUIRE_ERRNO
, ATF_TC
,
ATF_TC_BODY
, ATF_TC_BODY_NAME
,
ATF_TC_CLEANUP
,
ATF_TC_CLEANUP_NAME
,
ATF_TC_HEAD
, ATF_TC_HEAD_NAME
,
ATF_TC_NAME
,
ATF_TC_WITH_CLEANUP
,
ATF_TC_WITHOUT_HEAD
,
ATF_TP_ADD_TC
, ATF_TP_ADD_TCS
,
atf_tc_get_config_var
,
atf_tc_get_config_var_wd
,
atf_tc_get_config_var_as_bool
,
atf_tc_get_config_var_as_bool_wd
,
atf_tc_get_config_var_as_long
,
atf_tc_get_config_var_as_long_wd
,
atf_no_error
,
atf_tc_expect_death
,
atf_tc_expect_exit
,
atf_tc_expect_fail
,
atf_tc_expect_pass
,
atf_tc_expect_signal
,
atf_tc_expect_timeout
,
atf_tc_fail
,
atf_tc_fail_nonfatal
,
atf_tc_pass
, atf_tc_skip
,
atf_utils_cat_file
,
atf_utils_compare_file
,
atf_utils_copy_file
,
atf_utils_create_file
,
atf_utils_file_exists
,
atf_utils_fork
,
atf_utils_free_charpp
,
atf_utils_grep_file
,
atf_utils_grep_string
,
atf_utils_readline
,
atf_utils_redirect
,
atf_utils_wait
—
#include <atf-c.h>
ATF_CHECK
(expression);
ATF_CHECK_MSG
(expression,
fail_msg_fmt,
...);
ATF_CHECK_EQ
(expression_1,
expression_2);
ATF_CHECK_EQ_MSG
(expression_1,
expression_2,
fail_msg_fmt,
...);
ATF_CHECK_MATCH
(regexp,
string);
ATF_CHECK_MATCH_MSG
(regexp,
string,
fail_msg_fmt,
...);
ATF_CHECK_STREQ
(string_1,
string_2);
ATF_CHECK_STREQ_MSG
(string_1,
string_2,
fail_msg_fmt,
...);
ATF_CHECK_ERRNO
(exp_errno,
bool_expression);
ATF_REQUIRE
(expression);
ATF_REQUIRE_MSG
(expression,
fail_msg_fmt,
...);
ATF_REQUIRE_EQ
(expression_1,
expression_2);
ATF_REQUIRE_EQ_MSG
(expression_1,
expression_2,
fail_msg_fmt,
...);
ATF_REQUIRE_MATCH
(regexp,
string);
ATF_REQUIRE_MATCH_MSG
(regexp,
string,
fail_msg_fmt,
...);
ATF_REQUIRE_STREQ
(string_1,
string_2);
ATF_REQUIRE_STREQ_MSG
(string_1,
string_2,
fail_msg_fmt,
...);
ATF_REQUIRE_ERRNO
(exp_errno,
bool_expression);
ATF_TC
(name);
ATF_TC_BODY
(name,
tc);
ATF_TC_BODY_NAME
(name);
ATF_TC_CLEANUP
(name,
tc);
ATF_TC_CLEANUP_NAME
(name);
ATF_TC_HEAD
(name,
tc);
ATF_TC_HEAD_NAME
(name);
ATF_TC_NAME
(name);
ATF_TC_WITH_CLEANUP
(name);
ATF_TC_WITHOUT_HEAD
(name);
ATF_TP_ADD_TC
(tp_name,
tc_name);
ATF_TP_ADD_TCS
(tp_name);
atf_tc_get_config_var
(tc,
varname);
atf_tc_get_config_var_wd
(tc,
variable_name,
default_value);
atf_tc_get_config_var_as_bool
(tc,
variable_name);
atf_tc_get_config_var_as_bool_wd
(tc,
variable_name,
default_value);
atf_tc_get_config_var_as_long
(tc,
variable_name);
atf_tc_get_config_var_as_long_wd
(tc,
variable_name,
default_value);
atf_no_error
();
atf_tc_expect_death
(reason,
...);
atf_tc_expect_exit
(exitcode,
reason,
...);
atf_tc_expect_fail
(reason,
...);
atf_tc_expect_pass
();
atf_tc_expect_signal
(signo,
reason,
...);
atf_tc_expect_timeout
(reason,
...);
atf_tc_fail
(reason);
atf_tc_fail_nonfatal
(reason);
atf_tc_pass
();
atf_tc_skip
(reason);
void
atf_utils_cat_file
(const char
*file, const char *prefix);
bool
atf_utils_compare_file
(const char
*file, const char *contents);
void
atf_utils_copy_file
(const char
*source, const char *destination);
void
atf_utils_create_file
(const char
*file, const char *contents,
...);
void
atf_utils_file_exists
(const char
*file);
pid_t
atf_utils_fork
(void);
void
atf_utils_free_charpp
(char
**argv);
bool
atf_utils_grep_file
(const char
*regexp, const char *file,
...);
bool
atf_utils_grep_string
(const char
*regexp, const char *str,
...);
char *
atf_utils_readline
(int fd);
void
atf_utils_redirect
(const int fd,
const char *file);
void
atf_utils_wait
(const pid_t pid,
const int expected_exit_status, const
char *expected_stdout, const char
*expected_stderr);
... C-specific includes go here ... #include <atf-c.h> ATF_TC(tc1); ATF_TC_HEAD(tc1, tc) { ... first test case's header ... } ATF_TC_BODY(tc1, tc) { ... first test case's body ... } ATF_TC_WITH_CLEANUP(tc2); ATF_TC_HEAD(tc2, tc) { ... second test case's header ... } ATF_TC_BODY(tc2, tc) { ... second test case's body ... } ATF_TC_CLEANUP(tc2, tc) { ... second test case's cleanup ... } ATF_TC_WITHOUT_HEAD(tc3); ATF_TC_BODY(tc3, tc) { ... third test case's body ... } ... additional test cases ... ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tcs, tc1); ATF_TP_ADD_TC(tcs, tc2); ATF_TP_ADD_TC(tcs, tc3); ... add additional test cases ... return atf_no_error(); }
ATF_TC
(),
ATF_TC_WITH_CLEANUP
() or the
ATF_TC_WITHOUT_HEAD
() macros, which take a single
parameter specifiying the test case's name. ATF_TC
(),
requires to define a head and a body for the test case,
ATF_TC_WITH_CLEANUP
() requires to define a head, a
body and a cleanup for the test case and
ATF_TC_WITHOUT_HEAD
() requires only a body for the
test case. It is important to note that these do not set the
test case up for execution when the program is run. In order to do so, a later
registration is needed with the ATF_TP_ADD_TC
() macro
detailed in Program
initialization.
Later on, one must define the three parts of the body by means of
three functions. Their headers are given by the
ATF_TC_HEAD
(), ATF_TC_BODY
()
and ATF_TC_CLEANUP
() macros, all of which take the
test case name provided to the ATF_TC
()
ATF_TC_WITH_CLEANUP
(), or
ATF_TC_WITHOUT_HEAD
() macros and the name of the
variable that will hold a pointer to the test case data. Following each of
these, a block of code is expected, surrounded by the opening and closing
brackets.
main
() function. You should never define one on your
own, but rely on the library to do it for you. This is done by using the
ATF_TP_ADD_TCS
() macro, which is passed the name of
the object that will hold the test cases; i.e. the test program instance. This
name can be whatever you want as long as it is a valid variable identifier.
After the macro, you are supposed to provide the body of a
function, which should only use the ATF_TP_ADD_TC
()
macro to register the test cases the test program will execute and return a
success error code. The first parameter of this macro matches the name you
provided in the former call. The success status can be returned using the
atf_no_error
() function.
atf_tc_set_md_var
() method, which takes three
parameters: the first one points to the test case data, the second one
specifies the meta-data variable to be set and the third one specifies its
value. Both of them are strings.
atf_tc_has_config_var
(), const char
* atf_tc_get_config_var
(), const
char * atf_tc_get_config_var_wd
(),
bool
atf_tc_get_config_var_as_bool
(),
bool
atf_tc_get_config_var_as_bool_wd
(),
long
atf_tc_get_config_var_as_long
(), and the
long
atf_tc_get_config_var_as_long_wd
() functions, which
can be called in any of the three parts of a test case.
The ‘_wd’ variants take a default value for the variable which is returned if the variable is not defined. The other functions without the ‘_wd’ suffix require the variable to be defined.
atf_tc_require_prog
()
function, which takes the base name or full path of a single binary. Relative
paths are forbidden. If it is not found, the test case will be automatically
skipped.
atf_tc_fail_nonfatal
(), or at any
explicit call to atf_tc_pass
(),
atf_tc_fail
() or
atf_tc_skip
(). These three functions terminate the
execution of the test case immediately. The cleanup routine will be processed
afterwards in a completely automated way, regardless of the test case's
termination reason.
atf_tc_pass
() does not take any
parameters. atf_tc_fail
(),
atf_tc_fail_nonfatal
() and
atf_tc_skip
() take a format string and a variable
list of parameters, which describe, in a user-friendly manner, why the test
case failed or was skipped, respectively. It is very important to provide a
clear error message in both cases so that the user can quickly know why the
test did not pass.
Each test case has an internal state called ‘expect’ that describes what the test case expectations are at any point in time. The value of this property can change during execution by any of:
atf_tc_expect_death
(reason,
...)atf_tc_expect_exit
(exitcode,
reason, ...)atf_tc_expect_fail
(reason,
...)This mode is useful to reproduce actual known bugs in tests. Whenever the developer fixes the bug later on, the test case will start reporting a failure, signaling the developer that the test case must be adjusted to the new conditions. In this situation, it is useful, for example, to set reason as the bug number for tracking purposes.
atf_tc_expect_pass
()atf_tc_expect_signal
(signo,
reason, ...)atf_tc_expect_timeout
(reason,
...)The ‘REQUIRE’ variant of the macros immediately
abort the test case as soon as an error condition is detected by calling the
atf_tc_fail
() function. Use this variant whenever it
makes no sense to continue the execution of a test case when the checked
condition is not met. The ‘CHECK’ variant, on the other hand,
reports a failure as soon as it is encountered using the
atf_tc_fail_nonfatal
() function, but the execution
of the test case continues as if nothing had happened. Use this variant
whenever the checked condition is important as a result of the test case,
but there are other conditions that can be subsequently checked on the same
run without aborting.
Additionally, the ‘MSG’ variants take an extra set of parameters to explicitly specify the failure message. This failure message is formatted according to the printf(3) formatters.
ATF_CHECK
(),
ATF_CHECK_MSG
(),
ATF_REQUIRE
() and
ATF_REQUIRE_MSG
() take an expression and fail if the
expression evaluates to false.
ATF_CHECK_EQ
(),
ATF_CHECK_EQ_MSG
(),
ATF_REQUIRE_EQ
() and
ATF_REQUIRE_EQ_MSG
() take two expressions and fail
if the two evaluated values are not equal.
ATF_CHECK_MATCH
(),
ATF_CHECK_MATCH_MSG
(),
ATF_REQUIRE_MATCH
() and
ATF_REQUIRE_MATCH_MSG
() take a regular expression
and a string and fail if the regular expression does not match the given
string. Note that the regular expression is not anchored, so it will match
anywhere in the string.
ATF_CHECK_STREQ
(),
ATF_CHECK_STREQ_MSG
(),
ATF_REQUIRE_STREQ
() and
ATF_REQUIRE_STREQ_MSG
() take two strings and fail if
the two are not equal character by character.
ATF_CHECK_ERRNO
() and
ATF_REQUIRE_ERRNO
() take, first, the error code that
the check is expecting to find in the errno variable
and, second, a boolean expression that, if evaluates to true, means that a
call failed and errno has to be checked against the
first value.
atf-c-api
API to simplify the creation of a variety of
tests. In particular, these are useful to write tests for command-line
interfaces.
void
atf_utils_cat_file
(const char
*file, const char *prefix);
bool
atf_utils_compare_file
(const char
*file, const char *contents);
void
atf_utils_copy_file
(const char
*source, const char *destination);
void
atf_utils_create_file
(const char
*file, const char *contents,
...);
void
atf_utils_file_exists
(const char
*file);
pid_t
atf_utils_fork
(void);
atf_utils_wait
(). Fails the test case if the fork
fails, so this does not return an error.void
atf_utils_free_charpp
(char
**argv);
bool
atf_utils_grep_file
(const char
*regexp, const char *file,
...);
bool
atf_utils_grep_string
(const char
*regexp, const char *str,
...);
char *
atf_utils_readline
(int
fd);
void
atf_utils_redirect
(const int
fd, const char *file);
atf_utils_fork
().void
atf_utils_wait
(const pid_t
pid, const int expected_exit_status,
const char *expected_stdout, const
char *expected_stderr);
atf_utils_wait
(). The validation involves
checking that the subprocess exited cleanly and returned the code specified in
expected_exit_status and that its standard output and
standard error match the strings given in
expected_stdout and
expected_stderr.
If any of the expected_stdout or expected_stderr strings are prefixed with ‘save:’, then they specify the name of the file into which to store the stdout or stderr of the subprocess, and no comparison is performed.
#include <atf-c.h> ATF_TC(addition); ATF_TC_HEAD(addition, tc) { atf_tc_set_md_var(tc, "descr", "Sample tests for the addition operator"); } ATF_TC_BODY(addition, tc) { ATF_CHECK_EQ(0 + 0, 0); ATF_CHECK_EQ(0 + 1, 1); ATF_CHECK_EQ(1 + 0, 1); ATF_CHECK_EQ(1 + 1, 2); ATF_CHECK_EQ(100 + 200, 300); } ATF_TC(string_formatting); ATF_TC_HEAD(string_formatting, tc) { atf_tc_set_md_var(tc, "descr", "Sample tests for the snprintf"); } ATF_TC_BODY(string_formatting, tc) { char buf[1024]; snprintf(buf, sizeof(buf), "a %s", "string"); ATF_CHECK_STREQ_MSG("a string", buf, "%s is not working"); } ATF_TC(open_failure); ATF_TC_HEAD(open_failure, tc) { atf_tc_set_md_var(tc, "descr", "Sample tests for the open function"); } ATF_TC_BODY(open_failure, tc) { ATF_CHECK_ERRNO(ENOENT, open("non-existent", O_RDONLY) == -1); } ATF_TC(known_bug); ATF_TC_HEAD(known_bug, tc) { atf_tc_set_md_var(tc, "descr", "Reproduces a known bug"); } ATF_TC_BODY(known_bug, tc) { atf_tc_expect_fail("See bug number foo/bar"); ATF_CHECK_EQ(3, 1 + 1); atf_tc_expect_pass(); ATF_CHECK_EQ(3, 1 + 2); } ATF_TP_ADD_TCS(tp) { ATF_TP_ADD_TC(tp, addition); ATF_TP_ADD_TC(tp, string_formatting); ATF_TP_ADD_TC(tp, open_failure); ATF_TP_ADD_TC(tp, known_bug); return atf_no_error(); }
November 15, 2013 | NetBSD 9.0 |