| 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 test 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 10.0 |