/*-*- mode:C; -*- */

/*

 * Check: a unit test framework for C

 * Copyright (C) 2001, 2002 Arien Malec

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,

 * MA 02110-1301, USA.

 */

#ifndef CHECK_H

#define CHECK_H

#include <stddef.h>

#include <string.h>

#include <math.h>

#include <float.h>

#include <check_stdint.h>

/*

   Macros and functions starting with _ (underscore) are internal and

   may change without notice. You have been warned!.

*/

#ifdef __cplusplus

#define CK_CPPSTART extern "C" {

#define CK_CPPEND }

CK_CPPSTART

#endif

#if defined(__GNUC__) && defined(__GNUC_MINOR__)

#define GCC_VERSION_AT_LEAST(major, minor) \

((__GNUC__ > (major)) || \

 (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))

#else

#define GCC_VERSION_AT_LEAST(major, minor) 0

#endif

#if GCC_VERSION_AT_LEAST(2,95)

#define CK_ATTRIBUTE_UNUSED __attribute__ ((unused))

#else

#define CK_ATTRIBUTE_UNUSED

#endif /* GCC 2.95 */

#if GCC_VERSION_AT_LEAST(2,5)

#define CK_ATTRIBUTE_NORETURN __attribute__ ((noreturn))

#else

#define CK_ATTRIBUTE_NORETURN

#endif /* GCC 2.5 */

#include <sys/types.h>

#if defined(_MSC_VER)

/* define pid_t for Windows, as it is needed later */

#define pid_t int

#endif /* _MSC_VER */

/*

 * Used to create the linker script for hiding lib-local symbols. Shall

 * be put directly in front of the exported symbol.

 */

#define CK_EXPORT

/*

 * Used for MSVC to create the export attribute

 * CK_DLL_EXP is defined during the compilation of the library

 * on the command line.

 */

#ifndef CK_DLL_EXP

#define CK_DLL_EXP

#endif

/* check version numbers */

#define CHECK_MAJOR_VERSION (@CHECK_MAJOR_VERSION@)

#define CHECK_MINOR_VERSION (@CHECK_MINOR_VERSION@)

#define CHECK_MICRO_VERSION (@CHECK_MICRO_VERSION@)

CK_DLL_EXP extern int CK_EXPORT check_major_version;

CK_DLL_EXP extern int CK_EXPORT check_minor_version;

CK_DLL_EXP extern int CK_EXPORT check_micro_version;

#ifndef NULL

#define NULL ((void*)0)

#endif

/**

 * Type for a test case

 *

 * A TCase represents a test case.  Create with tcase_create, free

 * with tcase_free.  For the moment, test cases can only be run

 * through a suite

*/

typedef struct TCase TCase;

/**

 * Type for a test function

 */

typedef void (*TFun) (int);

/**

 * Type for a setup/teardown function

 */

typedef void (*SFun) (void);

/**

 * Type for a test suite

 */

typedef struct Suite Suite;

/**

 * Creates a test suite with the given name.

 *

 * Create a suite, which will contain test cases. Once

 * created, use suite_add_tcase() to add test cases.

 * When finished, create a suite runner from the

 * suite using srunner_create()

 *

 * @param name name of the suite

 *

 * @return suite

 *

 * @since 0.6.0

 */

CK_DLL_EXP Suite *CK_EXPORT suite_create(const char *name);

/**

 * Determines whether a given test suite contains a case named after a

 * given string.

 *

 * @param s suite to check

 * @param tcname test case to look for

 *

 * @return 1 iff the given test case is within the given suite;

 *          0 otherwise

 *

 * @since 0.9.9

 */

CK_DLL_EXP int CK_EXPORT suite_tcase(Suite * s, const char *tcname);

/**

 * Add a test case to a suite.

 *

 * Note that if the TCase has already been added attempting

 * to add it again will be ignored.

 *

 * @param s suite to add test case to

 * @param tc test case to add to suite

 *

 * @since 0.6.0

 */

CK_DLL_EXP void CK_EXPORT suite_add_tcase(Suite * s, TCase * tc);

/**

 * Create a test case.

 *

 * Once created, tests can be added with the tcase_add_test()

 * function, and the test case assigned to a suite with the

 * suite_add_tcase() function.

 *

 * @param name name of the test case

 *

 * @return test case containing no tests

 *

 * @since 0.6.0

 * */

CK_DLL_EXP TCase *CK_EXPORT tcase_create(const char *name);

/**

 * Associate a test case with certain tags.

 * Replaces any existing tags with the new set.

 *

 * @param tc the test case

 *

 * @param tags string containing arbitrary tags separated by spaces.

 *        This will be copied. Passing NULL clears all tags.

 *

 * @since 0.11.0

 * */

CK_DLL_EXP void CK_EXPORT tcase_set_tags(TCase * tc,

					 const char *tags);

/**

 * Add a test function to a test case

 *

 * @param tc test case to add test to

 * @param tf test function to add to test case

 *

 * @since 0.6.0

 * */

#define tcase_add_test(tc,tf) tcase_add_test_raise_signal(tc,tf,0)

/**

 * Add a test function with signal handling to a test case

 *

 * The added test is expected to terminate by throwing the given signal

 *

 * @param tc test case to add test to

 * @param tf test function to add to test case

 * @param signal expected signal for test function to throw in order for

 *                the test to be considered passing

 *

 * @since 0.9.2

 * */

#define tcase_add_test_raise_signal(tc,tf,signal) \

   _tcase_add_test((tc),(tf),"" # tf "",(signal), 0, 0, 1)

/**

 * Add a test function with an expected exit value to a test case

 *

 * The added test is expected to terminate by exiting with the given value

 *

 * @param tc test case to add test to

 * @param tf test function to add to test case

 * @param expected_exit_value exit value for test function to return in

 *                             order for the test to be considered passing

 *

 * @since 0.9.7

 */

#define tcase_add_exit_test(tc, tf, expected_exit_value) \

  _tcase_add_test((tc),(tf),"" # tf "",0,(expected_exit_value),0,1)

/**

 * Add a looping test function to a test case

 *

 * The test will be called in a for(i = s; i < e; i++) loop with each

 * iteration being executed in a new context. The loop variable 'i' is

 * available in the test.

 *

 * @param tc test case to add test to

 * @param tf function to add to test case

 * @param s starting index for value "i" in test

 * @param e ending index for value "i" in test

 *

 * @since 0.9.4

 */

#define tcase_add_loop_test(tc,tf,s,e) \

  _tcase_add_test((tc),(tf),"" # tf "",0,0,(s),(e))

/**

 * Add a looping test function with signal handling to a test case

 *

 * The test will be called in a for(i = s; i < e; i++) loop with each

 * iteration being executed in a new context. The loop variable 'i' is

 * available in the test.

 *

 * The added test is expected to terminate by throwing the given signal

 *

 * @param tc test case to add test to

 * @param tf function to add to test case

 * @param signal expected signal for test function to throw in order for

 *                the test to be considered passing

 * @param s starting index for value "i" in test

 * @param e ending index for value "i" in test

 *

 * @since 0.9.5

 */

#define tcase_add_loop_test_raise_signal(tc,tf,signal,s,e) \

  _tcase_add_test((tc),(tf),"" # tf "",(signal),0,(s),(e))

/**

 * Add a looping test function with an expected exit value to a test case

 *

 * The test will be called in a for(i = s; i < e; i++) loop with each

 * iteration being executed in a new context. The loop variable 'i' is

 * available in the test.

 *

 * The added test is expected to terminate by exiting with the given value

 *

 * @param tc test case to add test to

 * @param tf function to add to test case

 * @param expected_exit_value exit value for test function to return in

 *                             order for the test to be considered passing

 * @param s starting index for value "i" in test

 * @param e ending index for value "i" in test

 *

 * @since 0.9.7

 */

#define tcase_add_loop_exit_test(tc,tf,expected_exit_value,s,e) \

  _tcase_add_test((tc),(tf),"" # tf "",0,(expected_exit_value),(s),(e))

/* Add a test function to a test case

  (function version -- use this when the macro won't work

*/

CK_DLL_EXP void CK_EXPORT _tcase_add_test(TCase * tc, TFun tf,

                                          const char *fname, int _signal,

                                          int allowed_exit_value, int start,

                                          int end);

/**

 * Add unchecked fixture setup/teardown functions to a test case

 *

 * Unchecked fixture functions are run at the start and end of the

 * test case, and not before and after unit tests. Further,

 * unchecked fixture functions are not run in a separate address space,

 * like test functions, and so must not exit or signal (e.g.,

 * segfault).

 *

 * Also, when run in CK_NOFORK mode, unchecked fixture functions may

 * lead to different unit test behavior if unit tests change data

 * setup by the fixture functions.

 *

 * Note that if a setup function fails, the remaining setup functions

 * will be omitted, as will the test case and the teardown functions.

 * If a teardown function fails the remaining teardown functins will be

 * omitted.

 *

 * @param tc test case to add unchecked fixture setup/teardown to

 * @param setup function to add to be executed before the test case;

 *               if NULL no setup function is added

 * @param teardown function to add to be executed after the test case;

 *               if NULL no teardown function is added

 * @since 0.8.0

 */

CK_DLL_EXP void CK_EXPORT tcase_add_unchecked_fixture(TCase * tc, SFun setup,

                                                      SFun teardown);

/**

 * Add checked fixture setup/teardown functions to a test case

 *

 * Checked fixture functions are run before and after each unit test inside

 * of the address space of the test. Thus, if using CK_FORK

 * mode the separate process running the unit test will survive signals

 * or unexpected exits in the fixture function. Also, if the setup

 * function is idempotent, unit test behavior will be the same in

 * CK_FORK and CK_NOFORK modes.

 *

 * However, since fixture functions are run before and after each unit

 * test, they should not be expensive code.

 *

 * Note that if a setup function fails, the remaining setup functions

 * will be omitted, as will the test and the teardown functions. If a

 * teardown function fails the remaining teardown functins will be

 * omitted.

 *

 * @param tc test case to add checked fixture setup/teardown to

 * @param setup function to add to be executed before each unit test in

 *               the test case;  if NULL no setup function is added

 * @param teardown function to add to be executed after each unit test in

 *               the test case; if NULL no teardown function is added

 *

 * @since 0.8.0

*/

CK_DLL_EXP void CK_EXPORT tcase_add_checked_fixture(TCase * tc, SFun setup,

                                                    SFun teardown);

/**

 * Set the timeout for all tests in a test case.

 *

 * A test that lasts longer than the timeout (in seconds) will be killed

 * and thus fail with an error.

 *

 * If not set, the default timeout is one assigned at compile time. If

 * the environment variable CK_DEFAULT_TIMEOUT is defined and no timeout

 * is set, the value in the environment variable is used.

 *

 * If Check is compile without fork() support this call is ignored,

 * as timeouts are not possible.

 *

 * @param tc test case to assign timeout to

 * @param timeout to use, in seconds. If the value contains a decimal

 *                 portion, but no high resolution timer is available,

 *                 the value is rounded up to the nearest second.

 *

 * @since 0.9.2

 */

CK_DLL_EXP void CK_EXPORT tcase_set_timeout(TCase * tc, double timeout);

/* Internal function to mark the start of a test function */

CK_DLL_EXP void CK_EXPORT tcase_fn_start(const char *fname, const char *file,

                                         int line);

/**

 * Retreive the name of the current running test. This is the name

 * of the test passed to START_TEST. This is only valid when called

 * from a running test. The value return outside of a running test is

 * undefined.

 *

 * @since 0.11.0

 */

CK_DLL_EXP const char* CK_EXPORT tcase_name(void);

/**

 * Start a unit test with START_TEST(unit_name), end with END_TEST.

 *

 * One must use braces within a START_/END_ pair to declare new variables

 *

 * @since 0.6.0

 */

#define START_TEST(__testname)\

static void __testname (int _i CK_ATTRIBUTE_UNUSED)\

{\

  tcase_fn_start (""# __testname, __FILE__, __LINE__);

/**

 *  End a unit test

 *

 * @since 0.6.0

 */

#define END_TEST }

/*

 * Fail the test case unless expr is false

 *

 * This call is deprecated.

 */

#define fail_unless ck_assert_msg

/*

 * Fail the test case if expr is false

 *

 * This call is deprecated.

 *

 * NOTE: The space before the comma sign before ## is essential to be compatible

 * with gcc 2.95.3 and earlier.

 * FIXME: these macros may conflict with C89 if expr is

 * FIXME:   strcmp (str1, str2) due to excessive string length.

 */

#define fail_if(expr, ...)\

  (expr) ? \

     _ck_assert_failed(__FILE__, __LINE__, "Failure '"#expr"' occurred" , ## __VA_ARGS__, NULL) \

     : _mark_point(__FILE__, __LINE__)

/*

 * Fail the test

 *

 * This call is deprecated.

 */

#define fail ck_abort_msg

/*

 * This is called whenever an assertion fails.

 * Note that it only has the noreturn modifier when

 * using fork. If fork is unavailable, the function

 * calls longjmp() when a test assertion fails. Marking

 * the function as noreturn causes gcc to make assumptions

 * which are not valid, as longjmp() is like a return.

 */

#if @HAVE_FORK@

CK_DLL_EXP void CK_EXPORT _ck_assert_failed(const char *file, int line,

                                            const char *expr,

                                            ...) CK_ATTRIBUTE_NORETURN;

#else

CK_DLL_EXP void CK_EXPORT _ck_assert_failed(const char *file, int line,

                                            const char *expr, ...);

#endif

/**

 * Fail the test if expression is false

 *

 * @param expr expression to evaluate

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.6

 */

#define ck_assert(expr) ck_assert_msg(expr, NULL)

/* The space before the comma sign before ## is essential to be compatible

   with gcc 2.95.3 and earlier.

*/

/**

 * Fail the test if the expression is false; print message on failure

 *

 * @param expr expression to evaluate

 * @param ... message to print (in printf format) if expression is false

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.6

 */

#define ck_assert_msg(expr, ...) \

  (expr) ? \

     _mark_point(__FILE__, __LINE__) : \

     _ck_assert_failed(__FILE__, __LINE__, "Assertion '"#expr"' failed" , ## __VA_ARGS__, NULL)

/**

 * Unconditionally fail the test

 *

 * @note Once called, the remaining of the test is aborted

 *

 * @since 0.9.6

 */

#define ck_abort() ck_abort_msg(NULL)

/**

 * Unconditionally fail the test; print a message

 *

 * @param ... message to print (in printf format)

 *

 * @note Once called, the remaining of the test is aborted

 *

 * @since 0.9.6

 */

#define ck_abort_msg(...) _ck_assert_failed(__FILE__, __LINE__, "Failed" , ## __VA_ARGS__, NULL)

/* Signed and unsigned integer comparison macros with improved output compared to ck_assert(). */

/* OP may be any comparison operator. */

#define _ck_assert_int(X, OP, Y) do { \

  intmax_t _ck_x = (X); \

  intmax_t _ck_y = (Y); \

  ck_assert_msg(_ck_x OP _ck_y, "Assertion '%s' failed: %s == %jd, %s == %jd", #X" "#OP" "#Y, #X, _ck_x, #Y, _ck_y); \

} while (0)

/**

 * Check two signed integers to determine if X==Y

 *

 * If not X==Y, the test fails.

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.6

 */

#define ck_assert_int_eq(X, Y) _ck_assert_int(X, ==, Y)

/**

 * Check two signed integers to determine if X!=Y

 *

 * If not X!=Y, the test fails.

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.6

 */

#define ck_assert_int_ne(X, Y) _ck_assert_int(X, !=, Y)

/**

 * Check two signed integers to determine if X

 *

 * If not X

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.10

 */

#define ck_assert_int_lt(X, Y) _ck_assert_int(X, <, Y)

/**

 * Check two signed integers to determine if X<=Y

 *

 * If not X<=Y, the test fails.

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.10

 */

#define ck_assert_int_le(X, Y) _ck_assert_int(X, <=, Y)

/**

 * Check two signed integers to determine if X>Y

 *

 * If not X>Y, the test fails.

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.10

 */

#define ck_assert_int_gt(X, Y) _ck_assert_int(X, >, Y)

/**

 * Check two signed integers to determine if X>=Y

 *

 * If not X>=Y, the test fails.

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.10

 */

#define ck_assert_int_ge(X, Y) _ck_assert_int(X, >=, Y)

#define _ck_assert_uint(X, OP, Y) do { \

  uintmax_t _ck_x = (X); \

  uintmax_t _ck_y = (Y); \

  ck_assert_msg(_ck_x OP _ck_y, "Assertion '%s' failed: %s == %ju, %s == %ju", #X" "#OP" "#Y, #X, _ck_x, #Y, _ck_y); \

} while (0)

/**

 * Check two unsigned integers to determine if X==Y

 *

 * If not X==Y, the test fails.

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.10

 */

#define ck_assert_uint_eq(X, Y) _ck_assert_uint(X, ==, Y)

/**

 * Check two unsigned integers to determine if X!=Y

 *

 * If not X!=Y, the test fails.

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.10

 */

#define ck_assert_uint_ne(X, Y) _ck_assert_uint(X, !=, Y)

/**

 * Check two unsigned integers to determine if X

 *

 * If not X

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.10

 */

#define ck_assert_uint_lt(X, Y) _ck_assert_uint(X, <, Y)

/**

 * Check two unsigned integers to determine if X<=Y

 *

 * If not X<=Y, the test fails.

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.10

 */

#define ck_assert_uint_le(X, Y) _ck_assert_uint(X, <=, Y)

/**

 * Check two unsigned integers to determine if X>Y

 *

 * If not X>Y, the test fails.

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.10

 */

#define ck_assert_uint_gt(X, Y) _ck_assert_uint(X, >, Y)

/**

 * Check two unsigned integers to determine if X>=Y

 *

 * If not X>=Y, the test fails.

 *

 * @param X signed integer

 * @param Y signed integer to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.9.10

 */

#define ck_assert_uint_ge(X, Y) _ck_assert_uint(X, >=, Y)

/* Number of digits after the decimal point to output via printf */

#ifndef CK_FLOATING_DIG

# define CK_FLOATING_DIG 6

#endif /* CK_FLOATING_DIG */

/* Floating point number comparison macros with improved output

 * compared to ck_assert(). */

/* OP may be any comparison operator, TP is type, TM is type modifier. */

#define _ck_assert_floating(X, OP, Y, TP, TM) do { \

  TP _ck_x = (X); \

  TP _ck_y = (Y); \

  ck_assert_msg(_ck_x OP _ck_y, \

  "Assertion '%s' failed: %s == %.*" TM "g, %s == %.*" TM "g", \

  #X" "#OP" "#Y, \

  #X, (int)CK_FLOATING_DIG, _ck_x, \

  #Y, (int)CK_FLOATING_DIG, _ck_y); \

} while (0)

/* Check floating point number is finise. */

/* TP is type, TM is type modifier. */

#define _ck_assert_floating_finite(X, TP, TM) \

do { \

  TP _ck_x = (X); \

  ck_assert_msg(isfinite(_ck_x), \

    "Assertion '%s' failed: %s == %.*" TM "g", \

    #X" is finite", \

    #X, (int)CK_FLOATING_DIG, _ck_x); \

} while (0)

/* Check floating point number is infinise. */

/* TP is type, TM is type modifier. */

#define _ck_assert_floating_infinite(X, TP, TM) \

do { \

  TP _ck_x = (X); \

  ck_assert_msg(isinf(_ck_x), \

    "Assertion '%s' failed: %s == %.*" TM "g", \

    #X" is infinite", \

    #X, (int)CK_FLOATING_DIG, _ck_x); \

} while (0)

/* Check floating point number is "Not a Number". */

/* TP is type, TM is type modifier. */

#define _ck_assert_floating_nan(X, TP, TM) \

do { \

  TP _ck_x = (X); \

  ck_assert_msg(isnan(_ck_x), \

    "Assertion '%s' failed: %s == %.*" TM "g", \

    #X" is NaN", \

    #X, (int)CK_FLOATING_DIG, _ck_x); \

} while (0)

/* Check floating point number is not "Not a Number". */

/* TP is type, TM is type modifier. */

#define _ck_assert_floating_nonnan(X, TP, TM) \

do { \

  TP _ck_x = (X); \

  ck_assert_msg(!isnan(_ck_x), \

    "Assertion '%s' failed: %s == %.*" TM "g", \

    #X" is not NaN", \

    #X, (int)CK_FLOATING_DIG, _ck_x); \

} while (0)

/* Floating point tolerance comparison macros with improved output

 * compared to ck_assert(). */

/* OP, D can have values: >, -1; <, 1. */

#define _ck_assert_floating_op_tol(X, OP, Y, T, D, TP, TM) do { \

  TP _ck_x = (X); \

  TP _ck_y = (Y); \

  TP _ck_t = (T); \

  ck_assert_msg((_ck_x - _ck_y) OP _ck_t * (D), \

  "Assertion '%s' failed: %s == %.*" TM "g, %s == %.*" TM "g, %s == %.*" TM "g", \

  #X" "#OP"= "#Y", error < "#T, \

  #X, (int)CK_FLOATING_DIG, _ck_x, \

  #Y, (int)CK_FLOATING_DIG, _ck_y, \

  #T, (int)CK_FLOATING_DIG, _ck_t); \

} while (0)

/* Floating point tolerance comparison macros with improved output

 * compared to ck_assert(). */

/* OP can have values: <; >=. */

#define _ck_assert_floating_absdiff_op_tol(X, Y, OP, T, TP, TM) \

do { \

  TP _ck_x = (X); \

  TP _ck_y = (Y); \

  TP _ck_t = (T); \

  ck_assert_msg(fabsl(_ck_y - _ck_x) OP _ck_t, \

    "Assertion '%s' failed: %s == %.*" TM "g, %s == %.*" TM "g, %s == %.*" TM "g", \

    "fabsl("#Y" - "#X") "#OP" "#T, \

    #X, (int)CK_FLOATING_DIG, _ck_x, \

    #Y, (int)CK_FLOATING_DIG, _ck_y, \

    #T, (int)CK_FLOATING_DIG, _ck_t); \

} while (0)

/**

 * Check two single precision floating point numbers to determine if X == Y

 *

 * If not X == Y, the test fails.

 *

 * @param X floating point number (float)

 * @param Y floating point number (float) to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.11.0

 */

#define ck_assert_float_eq(X, Y) _ck_assert_floating(X, ==, Y, float, "")

/**

 * Check two single precision floating point numbers to determine if X != Y

 *

 * If not X != Y, the test fails.

 *

 * @param X floating point number (float)

 * @param Y floating point number (float) to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.11.0

 */

#define ck_assert_float_ne(X, Y) _ck_assert_floating(X, !=, Y, float, "")

/**

 * Check two single precision floating point numbers to determine if X < Y

 *

 * If not X < Y, the test fails.

 *

 * @param X floating point number (float)

 * @param Y floating point number (float) to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.11.0

 */

#define ck_assert_float_lt(X, Y) _ck_assert_floating(X, <, Y, float, "")

/**

 * Check two single precision floating point numbers to determine if X <= Y

 *

 * If not X <= Y, the test fails.

 *

 * @param X floating point number (float)

 * @param Y floating point number (float) to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.11.0

 */

#define ck_assert_float_le(X, Y) _ck_assert_floating(X, <=, Y, float, "")

/**

 * Check two single precision floating point numbers to determine if X > Y

 *

 * If not X > Y, the test fails.

 *

 * @param X floating point number (float)

 * @param Y floating point number (float) to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.11.0

 */

#define ck_assert_float_gt(X, Y) _ck_assert_floating(X, >, Y, float, "")

/**

 * Check two single precision floating point numbers to determine if X >= Y

 *

 * If not X >= Y, the test fails.

 *

 * @param X floating point number (float)

 * @param Y floating point number (float) to compare against X

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.11.0

 */

#define ck_assert_float_ge(X, Y) _ck_assert_floating(X, >=, Y, float, "")

/**

 * Check two single precision floating point numbers to determine if X≈Y

 * with specified tolerance

 *

 * If not X ≈ Y with error < T, the test fails.

 *

 * @param X floating point number (float)

 * @param Y floating point number (float) to compare against X

 * @param T tolerance (float)

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.11.0

 */

#define ck_assert_float_eq_tol(X, Y, T)  _ck_assert_floating_absdiff_op_tol(X, Y, <, T, float, "")

/**

 * Check two single precision floating point numbers to determine if not X≈Y

 * with specified tolerance

 *

 * If X ≈ Y with error < T, the test fails.

 *

 * @param X floating point number (float)

 * @param Y floating point number (float) to compare against X

 * @param T tolerance (float)

 *

 * @note If the check fails, the remaining of the test is aborted

 *

 * @since 0.11.0

 */