testlib.h

Go to the documentation of this file.

#ifndef _TESTLIB_H_
#define _TESTLIB_H_

#include <test_config.h>

#include <stdbool.h>
#include <stdlib.h> /* for size_t */
#include <stdint.h>

/* This file uses the 'do {...} while (0)' trick to create a regular statement
 * instead of a compound statement. This way can use this macro in code like
 *
 * if (<condition>)
 *   CALL_FUNCS(a);
 * else
 *   bar;
 *
 * Macros simply using '{ ... }' will not work this way, because the last ';' in
 * the compound statement terminates the IF. This will lead to a compiler error.
 *
 * Howver, using MS compilers on Warning Level 4, 'while (0)' creates a warninig
 * 'warning C4127: conditional expression is constant'. Therefore we create a
 * new macro ONCE which does disable the warning just for this case.
 */
#ifdef _MSC_VER
#  define ONCE __pragma(warning(push)) \
               __pragma(warning(disable:4127)) \
               while (0) \
               __pragma(warning(pop))
#else
#  define ONCE while (0)
#endif

#define UTEST_MAIN() int main(int argc, char *argv[]) { \
        return testlib_main(argc, argv); \
    }

#define UFATAL(condition) \
    do { \
        if (testlib_fatal(condition, #condition, __FILE__, __LINE__)) { \
            return; \
        } \
    } ONCE

#define UVERIFY(condition) \
    do { \
        if (testlib_verify(condition, #condition, __FILE__, __LINE__)) { \
            return; \
        } \
    } ONCE

#define UVERIFY2(condition, info) \
    do { \
        if (testlib_verify2(condition, #condition, info, __FILE__, __LINE__)) { \
            return; \
        } \
    } ONCE

#define UCOMPARE(actual, expected) \
    do { \
        if (testlib_compare(actual, expected, #actual, #expected, __FILE__, __LINE__)) { \
            return; \
        } \
    } ONCE

#define UCOMPARE64(actual, expected) \
    do { \
        if (testlib_compare64(actual, expected, #actual, #expected, __FILE__, __LINE__)) { \
            return; \
        } \
    } ONCE

#define UCOMPAREF(actual, expected) \
    do { \
        if (testlib_comparef(actual, expected, #actual, #expected, __FILE__, __LINE__)) { \
            return; \
        } \
    } ONCE

#define UFUZZY_COMPAREF(actual, expected) \
    do { \
        if (testlib_fuzzy_comparef(actual, expected, #actual, #expected, \
            __FILE__, __LINE__)) { \
            return; \
        } \
    } ONCE

#define UCOMPARESTR(actual, expected) \
    do { \
        if (testlib_comparestr(actual, expected, #actual, #expected, __FILE__, __LINE__)) { \
            return; \
        } \
    } ONCE

#define UCOMPAREMEM(actual, actuallen, expected, expectedlen) \
    do { \
        if (testlib_comparemem(actual, actuallen, expected, expectedlen, __FILE__, __LINE__)) { \
            return; \
        } \
    } ONCE

#define UREGISTER_NAME(name) \
    do { \
        testlib_register_name(name); \
    } ONCE

#define UREGISTER_INIT(func) \
    do { \
        testlib_register_init(func); \
    } ONCE

#define UREGISTER_CLEANUP(func) \
    do { \
        testlib_register_cleanup(func); \
    } ONCE

#define UREGISTER_TEST(test) \
    do { \
        testlib_register_test(test, #test, 0, 0); \
    } ONCE

#define UREGISTER_DATADRIVEN_TEST(test, testdata) \
    do { \
        testlib_register_datadriven_test(test, #test, testdata, #testdata, 0, 0); \
    } ONCE

#define UREGISTER_TEST2(test, init, cleanup) \
    do { \
        testlib_register_test(test, #test, init, cleanup); \
    } ONCE

#define UREGISTER_DATADRIVEN_TEST2(test, testdata, init, cleanup) \
    do { \
        testlib_register_datadriven_test(test, #test, testdata, #testdata, init, cleanup); \
    } ONCE


#define UEXPECT_FAIL(dataIndex, comment, mode) \
    do { \
        testlib_expect_fail(dataIndex, comment, mode); \
    } ONCE

enum testlib_fail_mode {
    Abort = 0, 
    Continue   
};

#ifdef ENABLE_BENCHMARK

# define UBENCHMARK for (test_benchmark_start(); test_benchmark_done(); test_benchmark_next())
void test_benchmark_start();
bool test_benchmark_done();
void test_benchmark_next();
#else
# define UBENCHMARK while (0)
#endif

int testlib_fatal(int condition, const char *scondition, const char *file, int line);
int testlib_verify(int condition, const char *scondition, const char *file, int line);
int testlib_verify2(int condition, const char *scondition, const char *info, const char *file, int line);
int testlib_compare(int actual, int expected, const char *sactual, const char *sexpected, const char *file, int line);
int testlib_compare64(int64_t actual, int64_t expected, const char *sactual, const char *sexpected, const char *file, int line);
int testlib_comparef(double actual, double expected, const char *sactual, const char *sexpected, const char *file, int line);
int testlib_fuzzy_comparef(double actual, double expected, const char *sactual, const char *sexpected, const char *file, int line);
int testlib_comparestr(const char *actual, const char *expected, const char *sactual, const char *sexpected, const char *file, int line);
int testlib_comparemem(const unsigned char *actual, size_t actuallen, const unsigned char *expected, size_t expectedlen, const char *file, int line);
void testlib_expect_fail(const char *dataIndex, const char *comment, enum testlib_fail_mode mode);

void testlib_add_column(const char *name, const char *fmt);
void testlib_add_row(const char *name, ...);
void *testlib_fetch(const char *name);
int testlib_fetch_int(const char *name);
unsigned int testlib_fetch_uint(const char *name);
double testlib_fetch_double(const char *name);

typedef void (*testfunction)();

void testlib_register_name(const char *name);
void testlib_register_init(testfunction func);
void testlib_register_cleanup(testfunction func);
void testlib_register_test(testfunction test, const char *stest, testfunction init, testfunction cleanup);
void testlib_register_datadriven_test(testfunction test, const char *stest, testfunction testdata, const char *stestdata, testfunction init, testfunction cleanup);
void testlib_run_tests(const char *testname, const char *testset);
void testlib_list_tests();
int testlib_verbose();
int testlib_silent();
void testlib_info(const char *msg);

struct testlib_stat {
    int num_tests;
    int num_passed;
    int num_failed;
    int num_skipped;
};

const struct testlib_stat *testlib_result();
int testlib_main(int argc, char *argv[]);

#define UINFO(msg) testlib_info(msg)

#endif /* _TESTLIB_H_ */