atto.h

Go to the documentation of this file.

 
#ifndef ATTO_H
#define ATTO_H
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#define ATTO_VERSION "1.4.0"
 
#include <stdio.h>  /* For printf() */
#include <math.h>   /* For fabs(), fabsf(), isnan(), isinf(), isfinite() */
#include <string.h> /* For strncmp(), memcmp() */
#include <stddef.h> /* For size_t */
 
extern char atto_at_least_one_fail;
 
extern size_t atto_counter_assert_failures;
 
extern size_t atto_counter_assert_passes;
 
#define ATTO_FLOAT_EQ_ABSTOL (1e-5f)
 
#define ATTO_DOUBLE_EQ_ABSTOL (1e-8)
 
 
#define atto_report() \
    printf("REPORT | File: %s:%d | Test case: %s" \
           " | Passes: %5zu | Failures: %5zu\n", \
           __FILE__, __LINE__, __func__,          \
           atto_counter_assert_passes, atto_counter_assert_failures)
 
#define atto_assert(expression) do {                   \
    if (!(expression)) {                               \
        printf("FAIL | File: %s:%d | Test case: %s\n", \
               __FILE__, __LINE__, __func__);          \
        atto_counter_assert_failures++;                \
        atto_at_least_one_fail = 1;                    \
        return;                                        \
    } else {                                           \
        atto_counter_assert_passes++;                  \
    }                                                  \
} while (0)
 
#define atto_true(x) atto_assert(x)
 
#define atto_false(x) atto_assert(!(x))
 
#define atto_eq(a, b) atto_assert((a) == (b))
 
#define atto_neq(a, b) atto_assert((a) != (b))
 
#define atto_gt(a, b) atto_assert((a) > (b))
 
#define atto_ge(a, b) atto_assert((a) >= (b))
 
#define atto_lt(a, b) atto_assert((a) < (b))
 
#define atto_le(a, b) atto_assert((a) <= (b))
 
#define atto_fdelta(a, b, delta) atto_assert(fabsf((a) - (b)) <= fabsf(delta))
 
#define atto_fapprox(a, b) atto_fdelta((a), (b), ATTO_FLOAT_EQ_ABSTOL)
 
#define atto_ddelta(a, b, delta) \
    atto_assert(fabs((a) - (b)) <= fabs(delta))
 
#define atto_dapprox(a, b) atto_ddelta((a), (b), ATTO_DOUBLE_EQ_ABSTOL)
 
#define atto_nan(value) atto_assert(isnan(value))
 
#define atto_inf(value) atto_assert(isinf(value))
 
#define atto_plusinf(value) atto_assert((isinf(value)) && ((value) > 0))
 
#define atto_minusinf(value) atto_assert((isinf(value)) && ((value) < 0))
 
#define atto_finite(value) atto_assert(isfinite(value))
 
#define atto_notfinite(value) atto_assert(!isfinite(value))
 
#define atto_flag(value, mask) atto_assert(((value) & (mask)))
 
#define atto_noflag(value, mask) atto_assert(((value) & (mask)) == 0)
 
#define atto_streq(a, b, maxlen) \
    atto_assert(strncmp((a), (b), (maxlen)) == 0)
 
#define atto_memeq(a, b, len) atto_assert(memcmp((a), (b), len) == 0)
 
#define atto_memneq(a, b, len) atto_assert(memcmp((a), (b), len) != 0)
 
#define atto_zeros(x, len) do { \
        for (size_t __atto_idx = 0; __atto_idx < (size_t)(len); __atto_idx++) \
        { atto_eq(((uint8_t*)(x))[__atto_idx], 0); } \
    } while(0)
 
#define atto_nzeros(x, len) do { \
        uint8_t __atto_all_zero = 1; \
        for (size_t __atto_idx = 0; __atto_idx < (size_t)(len); __atto_idx++) \
        { if(((uint8_t*)(x))[__atto_idx] != 0) \
            { __atto_all_zero = 0; break; } \
        } \
        atto_false(__atto_all_zero); \
    } while(0)
 
#define atto_fail() atto_assert(0)
 
#ifdef __cplusplus
}
#endif
 
#endif  /* ATTO_H */