Inside the ./utl/ folder there are many utility functions and macros that can be extensively used with the C Macro Collections library. Most of these utilities can be used without the main library.
./utl/
Definition of many typed non-abortive assertions. Every assertion that fails will print a message to stderr but will not abort the program execution. The macro parameters are first assigned to a temporary variable of the specified dtype in order to generate warnings from the compiler in case of type mismatch.
stderr
dtype
The advantage of these typed macros is that when an assertion fails, it is possible to print to stderr the actual value that was passed to the function and check the expected result(s) all in one message.
There are assertions that work with a single value to be tested and others that work with arrays. Single value assertions work with a selected list of dtype, while the assertion with arrays work with any dtype that is a valid data type.
The macro parameters can be an lvalue or an rvalue.
There are assertions that work with predefined values and others that work with generic values. Valued assertions work with a selected list of dtype (see further below), while the generic assertions work with any data type.
The macro parameters can be an lvalue or an rvalue because the parameters will be first assigned to local variables of the selected data type. Then, these local variables will be tested for whichever test that needs to be checked.
Assigning the macro parameter to a local variable can be useful. These local variables will be of type dtype and if the parameters don't match that type a warning will pop up.
Ever assertion is inside a block of do { } while (0).
do { } while (0)
Whenever an assertion fails, a message will be printed to stderr. The message will look something like this:
Assertion Failed at FILE:FUNCTION:LINE for { ACTUAL }: DETAILS +
The first information is the file where that assertion failed. Then the function name and the line number. Then in place of ACTUAL, a stringified version of the actual parameter, which is the variable being checked in the assertion, will be printed.
ACTUAL
actual
In DETAILS is where more information about the assertion will be printed. This is the most useful part of these macros. In here, the actual value of the variable will be printed along with the expected value or range or lower bound, etc. In here you will be able to debug your application to check the expected value(s) against the actual one.
DETAILS
Example
#include "utl/assert.h" + +void is_one_hundred(int variable) +{ + cmc_assert_equals(int32_t, 100, variable); +} + +int main(void) +{ + int my_var = 9; + is_one_hundred(my_var); +} +
This will print the following message:
Assertion Failed at main.c:is_one_hundred:5 for { variable }: Expected: 100 Actual: 9
This is a global variable that can be used to test if all assertions passed. If any assertion fails, this variable will be set to false. If an assertion passes this variable will not be set back to true. If you wish to, you can set the state back to true manually.
false
true
static bool cmc_assert_state = true; +
This variable is used in test.h utility to automatically pass or fail a unit test. Once the unit test finishes, this variable is set back to true so that another unit test may follow.
These are the data types supported by the single value assertion macros:
These are the data types supported by the Valued Assertion macros:
int8_t
int16_t
int32_t
int64_t
uint8_t
uint16_t
uint32_t
uint64_t
intmax_t
uintmax_t
size_t
float
double
The following two are only accepted by cmc_assert_equals and cmc_assert_not_equals:
cmc_assert_equals
cmc_assert_not_equals
ptr
bool
Note that ptr is used for any pointers. They are first casted to void * and then their address is compared.
void *
This is a global variable that can be used to test if all assertions passed. If a single assertion fails, this variable will be set to false. If an assertion passes this variable will not be set back to true.
static bool cmc_assert_state = true; -
Note that bool will be expanded to _Bool.
_Bool
dtpype
Asserts that an expression evaluates to true.
expression
#define cmc_assert(expression)
Parameters
Asserts that a
Asserts that a value equals another expected value.
#define cmc_assert_equals(dtype, expected, actual) +
expected
Asserts that a value does not equal another.
#define cmc_assert_not_equals(dtype, not_expected, actual) +
not_expected
Asserts that a value is above a certain lower boundary.
#define cmc_assert_greater(dtype, boundary, actual) +
boundary
Asserts that a value is above a certain lower boundary or equal to it.
#define cmc_assert_greater_equals(dtype, boundary, actual) +
Asserts that a value is below a certain upper boundary.
#define cmc_assert_lesser(dtype, boundary, actual) +
Asserts that a value is below a certain upper boundary or equal to it.
#define cmc_assert_lesser_equals(dtype, boundary, actual) +
Asserts that a value is within a certain range. Range is inclusive on both ends.
#define cmc_assert_in_range(dtype, lower_bound, upper_bound, actual) +
lower_bound
upper_bound
Asserts that a value is not within a certain range. Range is inclusive on both ends.
#define cmc_assert_not_in_range(dtype, lower_bound, upper_bound, actual) +
Assert that two arrays are equal element by element. from_index and to_index are both inclusive.
from_index
to_index
#define cmc_assert_array_equals_any(dtype, array1, array2, comparator, \ + from_index, to_index) +
array1
array2
comparator
Assert that each element in the array are within a certain boundary. Both ends are inclusive.
#define cmc_assert_array_within_any(dtype, array, comparator, lower_bound, \ + upper_bound, from_index, to_index) +
array
Assert that each element in the array are outside of a certain boundary. Both ends are inclusive.
#define cmc_assert_array_outside_any(dtype, array, comparator, lower_bound, \ + upper_bound, from_index, to_index) +
Asserts that an array is sorted.
#define cmc_assert_array_sorted_any(dtype, array, comparator, from_index, \ + to_index) +
For-Each macros. Since doing a for loop with iterators can be a lot to write, these macros solve that problem. There are two of them:
CMC_FOREACH
CMC_FOREAC_REV
PFX
SNAME
#define cmc_assert(expression) +
#define cmc_assert(expression) -
ITERNAME
TARGET
Logging utility.