tcs
, name
)
ATF_CHECK(
expression
)
ATF_CHECK_EQUAL(
expression_1
, expression_2
)
ATF_CHECK_THROW(
statement_1
, expected_exception
)
ATF_FAIL(
reason
)
ATF_INIT_TEST_CASES(
tcs
)
ATF_PASS(
)
ATF_SKIP(
reason
)
ATF_TEST_CASE(
name
)
ATF_TEST_CASE_BODY(
name
)
ATF_TEST_CASE_CLEANUP(
name
)
ATF_TEST_CASE_HEAD(
name
)
ATF_TEST_CASE_WITH_CLEANUP(
name
)
C++-based test programs always follow this template:
extern "C" {
... C-specific includes go here ...
}
... C++-specific includes go here ...
#include
ATF_TEST_CASE(tc1);
ATF_TEST_CASE_HEAD(tc1)
{
... first test case's header ...
}
ATF_TEST_CASE_BODY(tc1)
{
... first test case's body ...
}
ATF_TEST_CASE_WITH_CLEANUP(tc2);
ATF_TEST_CASE_HEAD(tc2)
{
... second test case's header ...
}
ATF_TEST_CASE_BODY(tc2)
{
... second test case's body ...
}
ATF_TEST_CASE_CLEANUP(tc2)
{
... second test case's cleanup ...
}
... additional test cases ...
ATF_INIT_TEST_CASES(tcs)
{
ATF_ADD_TEST_CASE(tcs, tc1)
ATF_ADD_TEST_CASE(tcs, tc2)
... add additional test cases ...
}
)
or the
ATF_TEST_CASE_WITH_CLEANUP(
)
macros, which take a single parameter specifiying the test case's
name.
The former does not allow the specification of a cleanup routine for the
test case while the latter does.
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 through the
ATF_ADD_TEST_CASE(
)
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_TEST_CASE_HEAD(),
ATF_TEST_CASE_BODY(
)
and
ATF_TEST_CASE_CLEANUP(
)
macros, all of which take the test case's name.
Following each of these, a block of code is expected, surrounded by the
opening and closing brackets.
)
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_INIT_TEST_CASES(
)
macro, which is passed the name of the list that will hold the test cases.
This name can be whatever you want as long as it is a valid variable value.
After the macro, you are supposed to provide the body of a function, which
should only use the
ATF_ADD_TEST_CASE()
macro to register the test cases the test program will execute.
The first parameter of this macro matches the name you provided in the
former call.
)
method, which takes two parameters: the first one specifies the
meta-data variable to be set and the second one specifies its value.
Both of them are strings.
bool
has_config_var(
)
and the
std::string
get_config_var(
)
methods, which can be called in any of the three parts of a test case.
)
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_FAIL(
)
or
ATF_SKIP(
).
These three macros 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_PASS()
does not take any parameters.
ATF_FAIL(
)
and
ATF_SKIP(
)
take a single string that describes 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.
)
with an appropriate error message.
ATF_CHECK()
takes an expression and raises a failure if it evaluates to false.
ATF_CHECK_EQUAL()
takes two expressions and raises a failure if the two do not evaluate to
the same exact value.
ATF_CHECK_THROW()
takes a statement and the name of an exception and raises a failure if
the statement did not throw the specified exception.
#include
ATF_TEST_CASE(addition);
ATF_TEST_CASE_HEAD(addition)
{
set("descr", "Sample tests for the addition operator");
}
ATF_TEST_CASE_BODY(addition)
{
ATF_CHECK_EQUAL(0 + 0, 0);
ATF_CHECK_EQUAL(0 + 1, 1);
ATF_CHECK_EQUAL(1 + 0, 1);
ATF_CHECK_EQUAL(1 + 1, 2);
ATF_CHECK_EQUAL(100 + 200, 300);
}
ATF_INIT_TEST_CASES(tcs)
{
ATF_ADD_TEST_CASE(tcs, addition);
}