[v1.2.1] Merge branch 'bleeding'
Changelog: * Added a cr_ prefix to all assertion macros. Old macros are deprecated and will be removed in a future version.
This commit is contained in:
Snaipe
commit
4a04a8a703
18 changed files with 274 additions and 185 deletions
10
.bumpversion.cfg
Normal file
10
.bumpversion.cfg
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
[bumpversion]
|
||||
current_version = 1.2.1
|
||||
commit = True
|
||||
|
||||
[bumpversion:file:configure.ac]
|
||||
|
||||
[bumpversion:file:doc/conf.py]
|
||||
|
||||
[bumpversion:file:appveyor.yml]
|
||||
|
||||
1
.gitignore
vendored
1
.gitignore
vendored
|
|
@ -2,6 +2,7 @@
|
|||
!*/
|
||||
|
||||
!.gitignore
|
||||
!.bumpversion.cfg
|
||||
|
||||
!*.c
|
||||
!*.h
|
||||
|
|
|
|||
|
|
@ -1,3 +1,9 @@
|
|||
2015-04-26 Franklin "Snaipe" Mathieu <franklinmathieu@gmail.com>
|
||||
|
||||
* criterion: version 1.2.1
|
||||
* Added a cr_ prefix to all assertion macros. Old macros are deprecated
|
||||
and will be removed in a future version.
|
||||
|
||||
2015-04-15 Franklin "Snaipe" Mathieu <franklinmathieu@gmail.com>
|
||||
|
||||
* criterion: version 1.2.0
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
version: 1.0.0_b{build}-{branch}
|
||||
version: 1.2.1_b{build}-{branch}
|
||||
|
||||
os: Windows Server 2012
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
AC_PREREQ([2.60])
|
||||
|
||||
AC_INIT([criterion], [1.2.0], [], [criterion], [franklinmathieu@gmail.com])
|
||||
AC_INIT([criterion], [1.2.1], [], [criterion], [franklinmathieu@gmail.com])
|
||||
AC_CONFIG_SRCDIR([src/runner.c])
|
||||
|
||||
LT_PREREQ([2.2.4])
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ copyright = u'2015, Franklin "Snaipe" Mathieu'
|
|||
# built documents.
|
||||
#
|
||||
# The short X.Y version.
|
||||
version = '1.2.0'
|
||||
version = '1.2.1'
|
||||
# The full version, including alpha/beta/rc tags.
|
||||
release = version
|
||||
|
||||
|
|
|
|||
|
|
@ -26,14 +26,14 @@ Asserting things
|
|||
|
||||
Assertions come in two kinds:
|
||||
|
||||
* ``assert*`` are assertions that are fatal to the current test if failed;
|
||||
* ``cr_assert*`` are assertions that are fatal to the current test if failed;
|
||||
in other words, if the condition evaluates to ``false``, the test is
|
||||
marked as a failure and the execution of the function is aborted.
|
||||
* ``expect*`` are, in the other hand, assertions that are not fatal to the
|
||||
* ``cr_expect*`` are, in the other hand, assertions that are not fatal to the
|
||||
test. Execution will continue even if the condition evaluates to
|
||||
``false``, but the test will be marked as a failure.
|
||||
|
||||
``assert()`` and ``expect()`` are the most simple kinds of assertions
|
||||
``cr_assert()`` and ``cr_expect()`` are the most simple kinds of assertions
|
||||
criterion has to offer. They both take a mandatory condition as a first
|
||||
parameter, and an optional failure message:
|
||||
|
||||
|
|
@ -43,45 +43,45 @@ parameter, and an optional failure message:
|
|||
#include <criterion/criterion.h>
|
||||
|
||||
Test(sample, test) {
|
||||
expect(strlen("Test") == 4, "Expected \"Test\" to have a length of 4.");
|
||||
expect(strlen("Hello") == 4, "This will always fail, why did I add this?");
|
||||
assert(strlen("") == 0);
|
||||
cr_expect(strlen("Test") == 4, "Expected \"Test\" to have a length of 4.");
|
||||
cr_expect(strlen("Hello") == 4, "This will always fail, why did I add this?");
|
||||
cr_assert(strlen("") == 0);
|
||||
}
|
||||
|
||||
On top of those, more assertions are available for common operations:
|
||||
|
||||
* ``assert_null(Ptr, [Message])``: passes if Ptr is NULL.
|
||||
* ``assert_eq(Actual, Expected, [Message])``: passes if Actual == Expected.
|
||||
* ``assert_lt(Actual, Expected, [Message])``: passes if Actual < Expected.
|
||||
* ``assert_leq(Actual, Expected, [Message])``: passes if Actual <= Expected.
|
||||
* ``assert_gt(Actual, Expected, [Message])``: passes if Actual > Expected.
|
||||
* ``assert_geq(Actual, Expected, [Message])``: passes if Actual >= Expected.
|
||||
* ``assert_float_eq(Actual, Expected, Epsilon, [Message])``:
|
||||
* ``cr_assert_null(Ptr, [Message])``: passes if Ptr is NULL.
|
||||
* ``cr_assert_eq(Actual, Expected, [Message])``: passes if Actual == Expected.
|
||||
* ``cr_assert_lt(Actual, Expected, [Message])``: passes if Actual < Expected.
|
||||
* ``cr_assert_leq(Actual, Expected, [Message])``: passes if Actual <= Expected.
|
||||
* ``cr_assert_gt(Actual, Expected, [Message])``: passes if Actual > Expected.
|
||||
* ``cr_assert_geq(Actual, Expected, [Message])``: passes if Actual >= Expected.
|
||||
* ``cr_assert_float_eq(Actual, Expected, Epsilon, [Message])``:
|
||||
passes if Actual == Expected with an error of Epsilon.
|
||||
* ``assert_arrays_eq(Actual, Expected, Size, [Message])``:
|
||||
* ``cr_assert_arrays_eq(Actual, Expected, Size, [Message])``:
|
||||
passes if all elements of Actual (from 0 to Size - 1) are equals to those
|
||||
of Expected.
|
||||
* ``assert_arrays_eq_cmp(Actual, Expected, Size, Cmp, [Message])``:
|
||||
* ``cr_assert_arrays_eq_cmp(Actual, Expected, Size, Cmp, [Message])``:
|
||||
Same as ``arrays_eq`` but equality is defined by the result of the binary
|
||||
Cmp function.
|
||||
|
||||
Equality and lexical comparison assertions are also available for strings:
|
||||
|
||||
* ``assert_strings_eq(Actual, Expected, [Message])``
|
||||
* ``assert_strings_lt(Actual, Expected, [Message])``
|
||||
* ``assert_strings_leq(Actual, Expected, [Message])``
|
||||
* ``assert_strings_gt(Actual, Expected, [Message])``
|
||||
* ``assert_strings_geq(Actual, Expected, [Message])``
|
||||
* ``cr_assert_strings_eq(Actual, Expected, [Message])``
|
||||
* ``cr_assert_strings_lt(Actual, Expected, [Message])``
|
||||
* ``cr_assert_strings_leq(Actual, Expected, [Message])``
|
||||
* ``cr_assert_strings_gt(Actual, Expected, [Message])``
|
||||
* ``cr_assert_strings_geq(Actual, Expected, [Message])``
|
||||
|
||||
And some assertions have a logical negative counterpart:
|
||||
|
||||
* ``assert_not(Condition, [Message])``
|
||||
* ``assert_not_null(Ptr, [Message])``
|
||||
* ``assert_neq(Actual, Unexpected, [Message])``
|
||||
* ``assert_float_neq(Actual, Unexpected, Epsilon, [Message])``
|
||||
* ``assert_strings_neq(Actual, Unexpected, [Message])``
|
||||
* ``assert_arrays_neq(Actual, Unexpected, Size, [Message])``
|
||||
* ``assert_arrays_neq_cmp(Actual, Unexpected, Size, Cmp, [Message])``
|
||||
* ``cr_assert_not(Condition, [Message])``
|
||||
* ``cr_assert_not_null(Ptr, [Message])``
|
||||
* ``cr_assert_neq(Actual, Unexpected, [Message])``
|
||||
* ``cr_assert_float_neq(Actual, Unexpected, Epsilon, [Message])``
|
||||
* ``cr_assert_strings_neq(Actual, Unexpected, [Message])``
|
||||
* ``cr_assert_arrays_neq(Actual, Unexpected, Size, [Message])``
|
||||
* ``cr_assert_arrays_neq_cmp(Actual, Unexpected, Size, Cmp, [Message])``
|
||||
|
||||
Of course, every ``assert`` has an ``expect`` counterpart.
|
||||
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ struct criterion_assert_args {
|
|||
int sentinel_;
|
||||
};
|
||||
|
||||
# define assert_impl(Kind, Condition, ...) \
|
||||
# define cr_assert_impl(Kind, Condition, ...) \
|
||||
do { \
|
||||
struct criterion_assert_args args = { \
|
||||
__VA_ARGS__ \
|
||||
|
|
@ -66,153 +66,154 @@ struct criterion_assert_args {
|
|||
|
||||
// Common asserts
|
||||
|
||||
# define abort_test(Message) \
|
||||
assert(0, \
|
||||
# define cr_abort_test(Message) \
|
||||
cr_assert(0, \
|
||||
.default_msg = "The conditions for this test were not met.", \
|
||||
.msg = (Message) \
|
||||
)
|
||||
|
||||
# define assert(...) assert_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect(...) expect_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert(...) cr_assert_(__VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_(Condition, ...) assert_impl(FATAL, Condition, __VA_ARGS__)
|
||||
# define expect_(Condition, ...) assert_impl(NORMAL, Condition, __VA_ARGS__)
|
||||
# define cr_expect(...) cr_expect_(__VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_not(...) assert_not_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_not(...) expect_not_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_(Condition, ...) cr_assert_impl(FATAL, Condition, __VA_ARGS__)
|
||||
# define cr_expect_(Condition, ...) cr_assert_impl(NORMAL, Condition, __VA_ARGS__)
|
||||
|
||||
# define assert_not_(Condition, ...) \
|
||||
assert_impl(FATAL, !(Condition), __VA_ARGS__)
|
||||
# define expect_not_(Condition, ...) \
|
||||
expect_impl(NORMAL, !(Condition), __VA_ARGS__)
|
||||
# define cr_assert_not(...) cr_assert_not_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_not(...) cr_expect_not_(__VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define cr_assert_not_(Condition, ...) \
|
||||
cr_assert_impl(FATAL, !(Condition), __VA_ARGS__)
|
||||
# define cr_expect_not_(Condition, ...) \
|
||||
cr_expect_impl(NORMAL, !(Condition), __VA_ARGS__)
|
||||
|
||||
// Native asserts
|
||||
|
||||
# define assert_op_(Op, Actual, Expected, ...) \
|
||||
assert_impl(FATAL, (Actual) Op (Expected), __VA_ARGS__)
|
||||
# define expect_op_(Op, Actual, Expected, ...) \
|
||||
assert_impl(NORMAL, (Actual) Op (Expected), __VA_ARGS__)
|
||||
# define cr_assert_op_(Op, Actual, Expected, ...) \
|
||||
cr_assert_impl(FATAL, (Actual) Op (Expected), __VA_ARGS__)
|
||||
# define cr_expect_op_(Op, Actual, Expected, ...) \
|
||||
cr_assert_impl(NORMAL, (Actual) Op (Expected), __VA_ARGS__)
|
||||
|
||||
# define assert_eq(...) assert_op_(==, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_eq(...) expect_op_(==, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_eq(...) cr_assert_op_(==, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_eq(...) cr_expect_op_(==, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_neq(...) assert_op_(!=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_neq(...) expect_op_(!=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_neq(...) cr_assert_op_(!=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_neq(...) cr_expect_op_(!=, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_lt(...) assert_op_(<, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_lt(...) expect_op_(<, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_lt(...) cr_assert_op_(<, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_lt(...) cr_expect_op_(<, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_gt(...) assert_op_(>, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_gt(...) expect_op_(>, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_gt(...) cr_assert_op_(>, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_gt(...) cr_expect_op_(>, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_leq(...) assert_op_(<=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_leq(...) expect_op_(<=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_leq(...) cr_assert_op_(<=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_leq(...) cr_expect_op_(<=, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_geq(...) assert_op_(>=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_geq(...) expect_op_(>=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_geq(...) cr_assert_op_(>=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_geq(...) cr_expect_op_(>=, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_null_(Value, ...) \
|
||||
assert_impl(FATAL, (Value) == NULL, __VA_ARGS__)
|
||||
# define expect_null_(Value, ...) \
|
||||
assert_impl(NORMAL, (Value) == NULL, __VA_ARGS__)
|
||||
# define cr_assert_null_(Value, ...) \
|
||||
cr_assert_impl(FATAL, (Value) == NULL, __VA_ARGS__)
|
||||
# define cr_expect_null_(Value, ...) \
|
||||
cr_assert_impl(NORMAL, (Value) == NULL, __VA_ARGS__)
|
||||
|
||||
# define assert_null(...) assert_null_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_null(...) expect_null_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_null(...) cr_assert_null_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_null(...) cr_expect_null_(__VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_not_null_(Value, ...) \
|
||||
assert_impl(FATAL, (Value) != NULL, __VA_ARGS__)
|
||||
# define expect_not_null_(Value, ...) \
|
||||
assert_impl(NORMAL, (Value) != NULL, __VA_ARGS__)
|
||||
# define cr_assert_not_null_(Value, ...) \
|
||||
cr_assert_impl(FATAL, (Value) != NULL, __VA_ARGS__)
|
||||
# define cr_expect_not_null_(Value, ...) \
|
||||
cr_assert_impl(NORMAL, (Value) != NULL, __VA_ARGS__)
|
||||
|
||||
# define assert_not_null(...) assert_not_null_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_not_null(...) expect_not_null_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_not_null(...) cr_assert_not_null_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_not_null(...) cr_expect_not_null_(__VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
// Floating-point asserts
|
||||
|
||||
# define assert_float_eq(...) \
|
||||
assert_float_eq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_float_eq(...) \
|
||||
expect_float_eq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_float_eq(...) \
|
||||
cr_assert_float_eq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_float_eq(...) \
|
||||
cr_expect_float_eq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_float_eq_(Actual, Expected, Epsilon, ...) \
|
||||
assert_impl(FATAL, (Expected) - (Actual) <= (Epsilon) \
|
||||
# define cr_assert_float_eq_(Actual, Expected, Epsilon, ...) \
|
||||
cr_assert_impl(FATAL, (Expected) - (Actual) <= (Epsilon) \
|
||||
&& (Actual) - (Expected) <= (Epsilon), \
|
||||
__VA_ARGS__)
|
||||
# define expect_float_eq_(Actual, Expected, Epsilon, ...) \
|
||||
assert_impl(NORMAL, (Expected) - (Actual) <= (Epsilon) \
|
||||
# define cr_expect_float_eq_(Actual, Expected, Epsilon, ...) \
|
||||
cr_assert_impl(NORMAL, (Expected) - (Actual) <= (Epsilon) \
|
||||
&& (Actual) - (Expected) <= (Epsilon), \
|
||||
__VA_ARGS__)
|
||||
|
||||
# define assert_float_neq(...) \
|
||||
assert_float_neq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_float_neq(...) \
|
||||
expect_float_neq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_float_neq(...) \
|
||||
cr_assert_float_neq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_float_neq(...) \
|
||||
cr_expect_float_neq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_float_neq_(Actual, Expected, Epsilon, ...) \
|
||||
assert_impl(FATAL, (Expected) - (Actual) > (Epsilon) \
|
||||
# define cr_assert_float_neq_(Actual, Expected, Epsilon, ...) \
|
||||
cr_assert_impl(FATAL, (Expected) - (Actual) > (Epsilon) \
|
||||
|| (Actual) - (Expected) > (Epsilon), \
|
||||
__VA_ARGS__)
|
||||
# define expect_float_neq_(Actual, Expected, Epsilon, ...) \
|
||||
assert_impl(NORMAL, (Expected) - (Actual) > (Epsilon) \
|
||||
# define cr_expect_float_neq_(Actual, Expected, Epsilon, ...) \
|
||||
cr_assert_impl(NORMAL, (Expected) - (Actual) > (Epsilon) \
|
||||
|| (Actual) - (Expected) > (Epsilon), \
|
||||
__VA_ARGS__)
|
||||
|
||||
// String asserts
|
||||
|
||||
# define assert_strings_(Op, Actual, Expected, ...) \
|
||||
assert_impl(FATAL, strcmp((Actual), (Expected)) Op 0, __VA_ARGS__)
|
||||
# define expect_strings_(Op, Actual, Expected, ...) \
|
||||
assert_impl(NORMAL, strcmp((Actual), (Expected)) Op 0, __VA_ARGS__)
|
||||
# define cr_assert_strings_(Op, Actual, Expected, ...) \
|
||||
cr_assert_impl(FATAL, strcmp((Actual), (Expected)) Op 0, __VA_ARGS__)
|
||||
# define cr_expect_strings_(Op, Actual, Expected, ...) \
|
||||
cr_assert_impl(NORMAL, strcmp((Actual), (Expected)) Op 0, __VA_ARGS__)
|
||||
|
||||
# define assert_strings_eq(...) \
|
||||
assert_strings_(==, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_strings_eq(...) \
|
||||
expect_strings_(==, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_strings_eq(...) \
|
||||
cr_assert_strings_(==, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_strings_eq(...) \
|
||||
cr_expect_strings_(==, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_strings_neq(...) \
|
||||
assert_strings_(!=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_strings_neq(...) \
|
||||
expect_strings_(!=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_strings_neq(...) \
|
||||
cr_assert_strings_(!=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_strings_neq(...) \
|
||||
cr_expect_strings_(!=, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_strings_gt(...) assert_strings_(>, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_strings_gt(...) expect_strings_(>, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_strings_gt(...) cr_assert_strings_(>, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_strings_gt(...) cr_expect_strings_(>, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_strings_lt(...) assert_strings_(<, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_strings_lt(...) expect_strings_(<, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_strings_lt(...) cr_assert_strings_(<, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_strings_lt(...) cr_expect_strings_(<, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_strings_leq(...) assert_strings_(<=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_strings_leq(...) expect_strings_(<=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_strings_leq(...) cr_assert_strings_(<=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_strings_leq(...) cr_expect_strings_(<=, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_strings_geq(...) assert_strings_(>=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_strings_geq(...) expect_strings_(>=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_strings_geq(...) cr_assert_strings_(>=, __VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_strings_geq(...) cr_expect_strings_(>=, __VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
// Array asserts
|
||||
|
||||
# define assert_arrays_eq(...) \
|
||||
assert_arrays_eq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_arrays_eq(...) \
|
||||
expect_arrays_eq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_arrays_eq(...) \
|
||||
cr_assert_arrays_eq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_arrays_eq(...) \
|
||||
cr_expect_arrays_eq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_arrays_neq(...) \
|
||||
assert_arrays_neq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_arrays_neq(...) \
|
||||
expect_arrays_neq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_arrays_neq(...) \
|
||||
cr_assert_arrays_neq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_arrays_neq(...) \
|
||||
cr_expect_arrays_neq_(__VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_arrays_eq_(A, B, Size, ...) \
|
||||
assert_impl(FATAL, !memcmp((A), (B), (Size)), \
|
||||
# define cr_assert_arrays_eq_(A, B, Size, ...) \
|
||||
cr_assert_impl(FATAL, !memcmp((A), (B), (Size)), \
|
||||
.default_msg = "Arrays are not equal.", \
|
||||
__VA_ARGS__)
|
||||
# define expect_arrays_eq_(A, B, Size, ...) \
|
||||
assert_impl(NORMAL, !memcmp((A), (B), (Size)), \
|
||||
# define cr_expect_arrays_eq_(A, B, Size, ...) \
|
||||
cr_assert_impl(NORMAL, !memcmp((A), (B), (Size)), \
|
||||
.default_msg = "Arrays are not equal.", \
|
||||
__VA_ARGS__)
|
||||
|
||||
# define assert_arrays_neq_(A, B, Size, ...) \
|
||||
assert_impl(FATAL, memcmp((A), (B), (Size)), \
|
||||
# define cr_assert_arrays_neq_(A, B, Size, ...) \
|
||||
cr_assert_impl(FATAL, memcmp((A), (B), (Size)), \
|
||||
.default_msg = "Arrays are equal", \
|
||||
__VA_ARGS__)
|
||||
# define expect_arrays_neq_(A, B, Size, ...) \
|
||||
assert_impl(NORMAL, memcmp((A), (B), (Size)), \
|
||||
# define cr_expect_arrays_neq_(A, B, Size, ...) \
|
||||
cr_assert_impl(NORMAL, memcmp((A), (B), (Size)), \
|
||||
.default_msg = "Arrays are equal", \
|
||||
__VA_ARGS__)
|
||||
|
||||
|
|
@ -221,50 +222,121 @@ struct criterion_assert_args {
|
|||
__typeof__(&(A)[0]) first = (A); \
|
||||
__typeof__(&(B)[0]) second = (B); \
|
||||
int equals = 1; \
|
||||
for (size_t i = 0, size = (Size); equals && i < size; ++i) \
|
||||
size_t i, size; \
|
||||
for (i = 0, size = (Size); equals && i < size; ++i) \
|
||||
equals = equals && !Cmp(first + i, second + i)
|
||||
|
||||
# define assert_arrays_eq_cmp_(A, B, Size, Cmp, ...) \
|
||||
# define cr_assert_arrays_eq_cmp_(A, B, Size, Cmp, ...) \
|
||||
do { \
|
||||
CRIT_ARR_COMPARE_(A, B, Size, Cmp, equals); \
|
||||
assert_impl(FATAL, equals, \
|
||||
cr_assert_impl(FATAL, equals, \
|
||||
.default_msg = "Arrays are not equal", \
|
||||
__VA_ARGS__); \
|
||||
} while (0)
|
||||
|
||||
# define expect_arrays_eq_cmp_(A, B, Size, Cmp, ...) \
|
||||
# define cr_expect_arrays_eq_cmp_(A, B, Size, Cmp, ...) \
|
||||
do { \
|
||||
CRIT_ARR_COMPARE_(A, B, Size, Cmp, equals); \
|
||||
assert_impl(NORMAL, equals, \
|
||||
cr_assert_impl(NORMAL, equals, \
|
||||
.default_msg = "Arrays are not equal", \
|
||||
__VA_ARGS__); \
|
||||
} while (0)
|
||||
|
||||
# define assert_arrays_eq_cmp(...) \
|
||||
assert_arrays_eq_cmp_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_arrays_eq_cmp(...) \
|
||||
expect_arrays_eq_cmp_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_arrays_eq_cmp(...) \
|
||||
cr_assert_arrays_eq_cmp_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_arrays_eq_cmp(...) \
|
||||
cr_expect_arrays_eq_cmp_(__VA_ARGS__, .sentinel_ = 0)
|
||||
|
||||
# define assert_arrays_neq_cmp_(A, B, Size, Cmp, ...) \
|
||||
# define cr_assert_arrays_neq_cmp_(A, B, Size, Cmp, ...) \
|
||||
do { \
|
||||
CRIT_ARR_COMPARE_(A, B, Size, Cmp, equals); \
|
||||
assert_impl(FATAL, !equals, \
|
||||
cr_assert_impl(FATAL, !equals, \
|
||||
.default_msg = "Arrays not equal", \
|
||||
__VA_ARGS__); \
|
||||
} while (0)
|
||||
|
||||
# define expect_arrays_neq_cmp_(A, B, Size, Cmp, ...) \
|
||||
# define cr_expect_arrays_neq_cmp_(A, B, Size, Cmp, ...) \
|
||||
do { \
|
||||
CRIT_ARR_COMPARE_(A, B, Size, Cmp, equals); \
|
||||
assert_impl(NORMAL, equals, \
|
||||
cr_assert_impl(NORMAL, equals, \
|
||||
.default_msg = "Arrays not equal", \
|
||||
__VA_ARGS__); \
|
||||
} while (0)
|
||||
|
||||
# define assert_arrays_neq_cmp(...) \
|
||||
assert_arrays_eq_cmp_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define expect_arrays_neq_cmp(...) \
|
||||
expect_arrays_eq_cmp_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_assert_arrays_neq_cmp(...) \
|
||||
cr_assert_arrays_eq_cmp_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# define cr_expect_arrays_neq_cmp(...) \
|
||||
cr_expect_arrays_eq_cmp_(__VA_ARGS__, .sentinel_ = 0)
|
||||
# endif /* !__GNUC__ */
|
||||
|
||||
// The section below is here for backward compatibility purposes.
|
||||
// It shall be removed in the text major version of Criterion
|
||||
# ifndef CRITERION_NO_COMPAT
|
||||
|
||||
# define CRITERION_ASSERT_DEPRECATED_(Name) CRITERION_ASSERT_DEPRECATED__( \
|
||||
message \
|
||||
"The `" #Name "` macro is deprecated, " \
|
||||
"please use `cr_" #Name "` instead." \
|
||||
)
|
||||
|
||||
# define CRITERION_ASSERT_DEPRECATED__(Msg) \
|
||||
_Pragma(#Msg)
|
||||
|
||||
# ifndef assert
|
||||
# define assert(...) CRITERION_ASSERT_DEPRECATED_(assert) cr_assert(__VA_ARGS__)
|
||||
|
||||
// this is needed to make the POSIX assert.h redefine assert if
|
||||
// subsequently included
|
||||
# ifndef _ASSERT_H
|
||||
# define _ASSERT_H 1
|
||||
# endif /* !_ASSERT_H */
|
||||
# endif /* !assert */
|
||||
|
||||
# define abort_test(Message) CRITERION_ASSERT_DEPRECATED_(abort_test) cr_abort_test(Message)
|
||||
# define expect(...) CRITERION_ASSERT_DEPRECATED_(expect) cr_expect(__VA_ARGS__)
|
||||
# define assert_not(...) CRITERION_ASSERT_DEPRECATED_(assert_not) cr_assert_not(__VA_ARGS__)
|
||||
# define expect_not(...) CRITERION_ASSERT_DEPRECATED_(expect_not) cr_expect_not(__VA_ARGS__)
|
||||
# define assert_eq(...) CRITERION_ASSERT_DEPRECATED_(assert_eq) cr_assert_eq(__VA_ARGS__)
|
||||
# define expect_eq(...) CRITERION_ASSERT_DEPRECATED_(expect_eq) cr_expect_eq(__VA_ARGS__)
|
||||
# define assert_neq(...) CRITERION_ASSERT_DEPRECATED_(assert_neq) cr_assert_neq(__VA_ARGS__)
|
||||
# define expect_neq(...) CRITERION_ASSERT_DEPRECATED_(expect_neq) cr_expect_neq(__VA_ARGS__)
|
||||
# define assert_lt(...) CRITERION_ASSERT_DEPRECATED_(assert_lt) cr_assert_lt(__VA_ARGS__)
|
||||
# define expect_lt(...) CRITERION_ASSERT_DEPRECATED_(expect_lt) cr_expect_lt(__VA_ARGS__)
|
||||
# define assert_gt(...) CRITERION_ASSERT_DEPRECATED_(assert_gt) cr_assert_gt(__VA_ARGS__)
|
||||
# define expect_gt(...) CRITERION_ASSERT_DEPRECATED_(expect_gt) cr_expect_gt(__VA_ARGS__)
|
||||
# define assert_leq(...) CRITERION_ASSERT_DEPRECATED_(assert_leq) cr_assert_leq(__VA_ARGS__)
|
||||
# define expect_leq(...) CRITERION_ASSERT_DEPRECATED_(expect_leq) cr_expect_leq(__VA_ARGS__)
|
||||
# define assert_geq(...) CRITERION_ASSERT_DEPRECATED_(assert_geq) cr_assert_geq(__VA_ARGS__)
|
||||
# define expect_geq(...) CRITERION_ASSERT_DEPRECATED_(expect_geq) cr_expect_geq(__VA_ARGS__)
|
||||
# define assert_null(...) CRITERION_ASSERT_DEPRECATED_(assert_null) cr_assert_null(__VA_ARGS__)
|
||||
# define expect_null(...) CRITERION_ASSERT_DEPRECATED_(expect_null) cr_expect_null(__VA_ARGS__)
|
||||
# define assert_not_null(...) CRITERION_ASSERT_DEPRECATED_(assert_not_null) cr_assert_not_null(__VA_ARGS__)
|
||||
# define expect_not_null(...) CRITERION_ASSERT_DEPRECATED_(expect_not_null) cr_expect_not_null(__VA_ARGS__)
|
||||
# define assert_float_eq(...) CRITERION_ASSERT_DEPRECATED_(assert_float_eq) cr_assert_float_eq(__VA_ARGS__)
|
||||
# define expect_float_eq(...) CRITERION_ASSERT_DEPRECATED_(expect_float_eq) cr_expect_float_eq(__VA_ARGS__)
|
||||
# define assert_float_neq(...) CRITERION_ASSERT_DEPRECATED_(assert_float_neq) cr_assert_float_neq(__VA_ARGS__)
|
||||
# define expect_float_neq(...) CRITERION_ASSERT_DEPRECATED_(expect_float_neq) cr_expect_float_neq(__VA_ARGS__)
|
||||
# define assert_strings_eq(...) CRITERION_ASSERT_DEPRECATED_(assert_strings_eq) cr_assert_strings_eq(__VA_ARGS__)
|
||||
# define expect_strings_eq(...) CRITERION_ASSERT_DEPRECATED_(expect_strings_eq) cr_expect_strings_eq(__VA_ARGS__)
|
||||
# define assert_strings_neq(...) CRITERION_ASSERT_DEPRECATED_(assert_strings_neq) cr_assert_strings_neq(__VA_ARGS__)
|
||||
# define expect_strings_neq(...) CRITERION_ASSERT_DEPRECATED_(expect_strings_neq) cr_expect_strings_neq(__VA_ARGS__)
|
||||
# define assert_strings_gt(...) CRITERION_ASSERT_DEPRECATED_(assert_strings_gt) cr_assert_strings_gt(__VA_ARGS__)
|
||||
# define expect_strings_gt(...) CRITERION_ASSERT_DEPRECATED_(expect_strings_gt) cr_expect_strings_gt(__VA_ARGS__)
|
||||
# define assert_strings_lt(...) CRITERION_ASSERT_DEPRECATED_(assert_strings_lt) cr_assert_strings_lt(__VA_ARGS__)
|
||||
# define expect_strings_lt(...) CRITERION_ASSERT_DEPRECATED_(expect_strings_lt) cr_expect_strings_lt(__VA_ARGS__)
|
||||
# define assert_strings_leq(...) CRITERION_ASSERT_DEPRECATED_(assert_strings_leq) cr_assert_strings_leq(__VA_ARGS__)
|
||||
# define expect_strings_leq(...) CRITERION_ASSERT_DEPRECATED_(expect_strings_leq) cr_expect_strings_leq(__VA_ARGS__)
|
||||
# define assert_strings_geq(...) CRITERION_ASSERT_DEPRECATED_(assert_strings_geq) cr_assert_strings_geq(__VA_ARGS__)
|
||||
# define expect_strings_geq(...) CRITERION_ASSERT_DEPRECATED_(expect_strings_geq) cr_expect_strings_geq(__VA_ARGS__)
|
||||
# define assert_arrays_eq(...) CRITERION_ASSERT_DEPRECATED_(assert_arrays_eq) cr_assert_arrays_eq(__VA_ARGS__)
|
||||
# define expect_arrays_eq(...) CRITERION_ASSERT_DEPRECATED_(expect_arrays_eq) cr_expect_arrays_eq(__VA_ARGS__)
|
||||
# define assert_arrays_neq(...) CRITERION_ASSERT_DEPRECATED_(assert_arrays_neq) cr_assert_arrays_neq(__VA_ARGS__)
|
||||
# define expect_arrays_neq(...) CRITERION_ASSERT_DEPRECATED_(expect_arrays_neq) cr_expect_arrays_neq(__VA_ARGS__)
|
||||
# define assert_arrays_eq_cmp(...) CRITERION_ASSERT_DEPRECATED_(assert_arrays_eq_cmp) cr_assert_arrays_eq_cmp(__VA_ARGS__)
|
||||
# define expect_arrays_eq_cmp(...) CRITERION_ASSERT_DEPRECATED_(expect_arrays_eq_cmp) cr_expect_arrays_eq_cmp(__VA_ARGS__)
|
||||
# define assert_arrays_neq_cmp(...) CRITERION_ASSERT_DEPRECATED_(assert_arrays_neq_cmp) cr_assert_arrays_neq_cmp(__VA_ARGS__)
|
||||
# define expect_arrays_neq_cmp(...) CRITERION_ASSERT_DEPRECATED_(expect_arrays_neq_cmp) cr_expect_arrays_neq_cmp(__VA_ARGS__)
|
||||
|
||||
# endif
|
||||
|
||||
#endif /* !CRITERION_ASSERT_H_ */
|
||||
|
|
|
|||
|
|
@ -1,54 +1,54 @@
|
|||
#include <criterion/criterion.h>
|
||||
|
||||
Test(asserts, base) {
|
||||
assert(true);
|
||||
expect(true);
|
||||
cr_assert(true);
|
||||
cr_expect(true);
|
||||
|
||||
assert(true, "Assertions may take failure messages");
|
||||
cr_assert(true, "Assertions may take failure messages");
|
||||
|
||||
assert(true, .msg = "You can use explicit named arguments");
|
||||
cr_assert(true, .msg = "You can use explicit named arguments");
|
||||
|
||||
expect(false, "assert is fatal, expect isn't");
|
||||
assert(false, "This assert runs");
|
||||
assert(false, "This does not");
|
||||
cr_expect(false, "assert is fatal, expect isn't");
|
||||
cr_assert(false, "This assert runs");
|
||||
cr_assert(false, "This does not");
|
||||
}
|
||||
|
||||
Test(asserts, old_school) {
|
||||
if (false)
|
||||
abort_test("You can abort the test with a message from anywhere");
|
||||
cr_abort_test("You can abort the test with a message from anywhere");
|
||||
|
||||
abort_test(NULL); // or without a message
|
||||
cr_abort_test(NULL); // or without a message
|
||||
}
|
||||
|
||||
Test(asserts, string) {
|
||||
assert_strings_eq("hello", "hello");
|
||||
assert_strings_neq("hello", "olleh");
|
||||
cr_assert_strings_eq("hello", "hello");
|
||||
cr_assert_strings_neq("hello", "olleh");
|
||||
|
||||
assert_strings_gt("hello", "hell");
|
||||
assert_strings_geq("hello", "hell");
|
||||
assert_strings_geq("hello", "hello");
|
||||
cr_assert_strings_gt("hello", "hell");
|
||||
cr_assert_strings_geq("hello", "hell");
|
||||
cr_assert_strings_geq("hello", "hello");
|
||||
|
||||
assert_strings_lt("hell", "hello");
|
||||
assert_strings_leq("hell", "hello");
|
||||
assert_strings_leq("hello", "hello");
|
||||
cr_assert_strings_lt("hell", "hello");
|
||||
cr_assert_strings_leq("hell", "hello");
|
||||
cr_assert_strings_leq("hello", "hello");
|
||||
}
|
||||
|
||||
Test(asserts, native) {
|
||||
assert_eq(1, 1);
|
||||
assert_neq(1, 2);
|
||||
cr_assert_eq(1, 1);
|
||||
cr_assert_neq(1, 2);
|
||||
|
||||
assert_lt(1, 2);
|
||||
assert_leq(1, 2);
|
||||
assert_leq(2, 2);
|
||||
cr_assert_lt(1, 2);
|
||||
cr_assert_leq(1, 2);
|
||||
cr_assert_leq(2, 2);
|
||||
|
||||
assert_gt(2, 1);
|
||||
assert_geq(2, 1);
|
||||
assert_geq(2, 2);
|
||||
cr_assert_gt(2, 1);
|
||||
cr_assert_geq(2, 1);
|
||||
cr_assert_geq(2, 2);
|
||||
}
|
||||
|
||||
Test(asserts, float) {
|
||||
assert_neq(0.1 * 0.1, 0.01);
|
||||
assert_float_eq(0.1 * 0.1, 0.01, 0.001);
|
||||
cr_assert_neq(0.1 * 0.1, 0.01);
|
||||
cr_assert_float_eq(0.1 * 0.1, 0.01, 0.001);
|
||||
}
|
||||
|
||||
struct dummy_struct {
|
||||
|
|
@ -72,9 +72,9 @@ Test(asserts, array) {
|
|||
s2[1].a = 2;
|
||||
s2[1].b = 4;
|
||||
|
||||
assert_arrays_eq(arr1, arr1, 4);
|
||||
assert_arrays_neq(arr1, arr2, 4);
|
||||
cr_assert_arrays_eq(arr1, arr1, 4);
|
||||
cr_assert_arrays_neq(arr1, arr2, 4);
|
||||
|
||||
assert_arrays_neq(s1, s2, 2);
|
||||
assert_arrays_eq_cmp(s1, s2, 2, eq_dummy);
|
||||
cr_assert_arrays_neq(s1, s2, 2);
|
||||
cr_assert_arrays_eq_cmp(s1, s2, 2, eq_dummy);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#include <criterion/criterion.h>
|
||||
|
||||
Test(misc, failing, .description = "Just a failing test") {
|
||||
assert(0);
|
||||
cr_assert(0);
|
||||
}
|
||||
|
||||
Test(misc, skipped, .description = "This one is skipped", .disabled = true) {
|
||||
|
|
|
|||
|
|
@ -10,5 +10,5 @@ void teardown(void) {
|
|||
}
|
||||
|
||||
Test(simple, fixtures, .init = setup, .fini = teardown) {
|
||||
assert(1);
|
||||
cr_assert(1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#include <criterion/criterion.h>
|
||||
|
||||
Test(sample, long_msg) {
|
||||
assert(0, "This is\nA long message\nSpawning multiple lines.\n\nFormatting is respected.");
|
||||
cr_assert(0, "This is\nA long message\nSpawning multiple lines.\n\nFormatting is respected.");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,11 +9,11 @@ void teardown_suite(void) {
|
|||
TestSuite(suite1, .init = setup_suite, .fini = teardown_suite);
|
||||
|
||||
Test(suite1, test) {
|
||||
assert(1);
|
||||
cr_assert(1);
|
||||
}
|
||||
|
||||
Test(suite2, test) {
|
||||
assert(1);
|
||||
cr_assert(1);
|
||||
}
|
||||
|
||||
TestSuite(disabled, .disabled = true);
|
||||
|
|
|
|||
|
|
@ -6,9 +6,9 @@ void crash(void) {
|
|||
}
|
||||
|
||||
Test(misc, setup_crash, .init = crash) {
|
||||
assert(true);
|
||||
cr_assert(true);
|
||||
}
|
||||
|
||||
Test(misc, teardown_crash, .fini = crash) {
|
||||
assert(true);
|
||||
cr_assert(true);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,8 +2,8 @@
|
|||
#include <criterion/criterion.h>
|
||||
|
||||
Test(sample, test) {
|
||||
expect(0);
|
||||
assert(1);
|
||||
cr_expect(0);
|
||||
cr_assert(1);
|
||||
}
|
||||
|
||||
ReportHook(PRE_INIT)(struct criterion_test *test) {
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#include <criterion/criterion.h>
|
||||
|
||||
Test(misc, failing) {
|
||||
assert(0);
|
||||
cr_assert(0);
|
||||
}
|
||||
|
||||
Test(misc, passing) {
|
||||
assert(1);
|
||||
cr_assert(1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#include <criterion/criterion.h>
|
||||
|
||||
Test(first_suite, test) {
|
||||
assert(1);
|
||||
cr_assert(1);
|
||||
}
|
||||
|
||||
Test(second_suite, test) {
|
||||
assert(1);
|
||||
cr_assert(1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
#include <criterion/criterion.h>
|
||||
|
||||
Test(samples, timed) {
|
||||
assert(0);
|
||||
cr_assert(0);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue