unittest.h

Go to the documentation of this file.

#pragma once
 
#include "zeroerr/internal/config.h"
 
#include <chrono>
#include <functional>
#include <string>
#include <vector>
 
ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH
 
#define ZEROERR_CREATE_TEST_FUNC(function, name, ...)                          \
    ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH                                      \
    static void                     function(zeroerr::TestContext*);           \
    static zeroerr::detail::regTest ZEROERR_NAMEGEN(_zeroerr_reg)(             \
        zeroerr::TestCase(name, __FILE__, __LINE__, function, {__VA_ARGS__})); \
    ZEROERR_SUPPRESS_COMMON_WARNINGS_POP;                                      \
    static void function(ZEROERR_UNUSED(zeroerr::TestContext* _ZEROERR_TEST_CONTEXT))
 
#define TEST_CASE(...) \
    ZEROERR_EXPAND(ZEROERR_CREATE_TEST_FUNC(ZEROERR_NAMEGEN(_zeroerr_testcase), __VA_ARGS__))
 
#define ZEROERR_CREATE_SUB_CASE(name, ...)                                           \
    zeroerr::SubCase(name, __FILE__, __LINE__, _ZEROERR_TEST_CONTEXT, {__VA_ARGS__}) \
        << [=](ZEROERR_UNUSED(zeroerr::TestContext * _ZEROERR_TEST_CONTEXT)) mutable
 
#define SUB_CASE(...)                                                         \
    ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH                                     \
    ZEROERR_EXPAND(ZEROERR_CREATE_SUB_CASE(__VA_ARGS__))                      \
    ZEROERR_SUPPRESS_COMMON_WARNINGS_POP
 
#define ZEROERR_CREATE_TEST_CLASS(fixture, classname, funcname, name, ...)                   \
    class classname : public fixture {                                                       \
    public:                                                                                  \
        void funcname(zeroerr::TestContext*);                                                \
    };                                                                                       \
    static void ZEROERR_CAT(call_, funcname)(zeroerr::TestContext * _ZEROERR_TEST_CONTEXT) { \
        classname instance;                                                                  \
        instance.funcname(_ZEROERR_TEST_CONTEXT);                                            \
    }                                                                                        \
    static zeroerr::detail::regTest ZEROERR_NAMEGEN(_zeroerr_reg)(                           \
        zeroerr::TestCase(name, __FILE__, __LINE__, ZEROERR_CAT(call_, funcname),            \
                          {__VA_ARGS__}));                                                   \
    inline void classname::funcname(ZEROERR_UNUSED(zeroerr::TestContext* _ZEROERR_TEST_CONTEXT))
 
#define TEST_CASE_FIXTURE(fixture, ...)                                              \
    ZEROERR_EXPAND(ZEROERR_CREATE_TEST_CLASS(fixture, ZEROERR_NAMEGEN(_zeroerr_class), \
                              ZEROERR_NAMEGEN(_zeroerr_test_method), __VA_ARGS__))
 
 
#define ZEROERR_HAVE_SAME_OUTPUT _ZEROERR_TEST_CONTEXT->save_output();
 
#ifndef ZEROERR_DISABLE_BDD
#define SCENARIO(...) TEST_CASE("Scenario: " __VA_ARGS__)
#define GIVEN(...)    SUB_CASE("given: " __VA_ARGS__)
#define WHEN(...)     SUB_CASE("when: " __VA_ARGS__)
#define THEN(...)     SUB_CASE("then: " __VA_ARGS__)
#endif
 
namespace zeroerr {
 
class IReporter;
struct TestCase;
class Decorator;
 
class TestContext {
public:
    unsigned passed     = 0;
    unsigned warning    = 0;
    unsigned failed     = 0;
    unsigned skipped    = 0;
    unsigned passed_as  = 0;
    unsigned warning_as = 0;
    unsigned failed_as  = 0;
    unsigned skipped_as = 0;
 
    std::chrono::duration<double> duration = std::chrono::duration<double>::zero();
 
    IReporter& reporter;
 
    int add(TestContext& local);
 
    void reset();
 
    void save_output();
 
    TestContext(IReporter& reporter) : reporter(reporter) {}
    ~TestContext() = default;
};
 
struct UnitTest {
    UnitTest& parseArgs(int argc, const char** argv);
 
    int run();
 
    bool run_filter(const TestCase& tc);
 
    bool            silent          = false;
    bool            run_bench       = false;
    bool            run_fuzz        = false;
    bool            list_test_cases = false;
    bool            no_color        = false;
    bool            log_to_report   = false;
    std::string     correct_output_path;
    std::string     reporter_name = "console";
    std::string     binary;
    struct Filters* filters;
};
 
struct TestCase {
    std::string                       name;
    std::string                       file;
    unsigned                          line;
    std::function<void(TestContext*)> func;
    std::vector<TestCase*>            subcases;
    std::vector<Decorator*>           decorators;
    bool operator<(const TestCase& rhs) const;
 
    TestCase(std::string name, std::string file, unsigned line, std::vector<Decorator*> decorators)
        : name(name), file(file), line(line), decorators(decorators) {}
 
    TestCase(std::string name, std::string file, unsigned line,
             std::function<void(TestContext*)> func, std::vector<Decorator*> decorators)
        : name(name), file(file), line(line), func(func), decorators(decorators) {}
};
 
 
struct SubCase : TestCase {
    SubCase(std::string name, std::string file, unsigned line, TestContext* context,
            std::vector<Decorator*> decorators);
    ~SubCase() = default;
    TestContext* context;
    void         operator<<(std::function<void(TestContext*)> op);
};
 
 
template <typename T>
struct TestedObjects {
    void           add(T&& obj) { objects.push_back(std::forward<T>(obj)); }
    std::vector<T> objects;
};
 
 
class IReporter {
public:
    virtual ~IReporter() = default;
 
    virtual std::string getName() const = 0;
 
    // There are a list of events
    virtual void testStart()                                           = 0;
    virtual void testCaseStart(const TestCase& tc, std::stringbuf& sb) = 0;
    virtual void testCaseEnd(const TestCase& tc, std::stringbuf& sb, const TestContext& ctx,
                             int type)                                 = 0;
    virtual void subCaseStart(const TestCase& tc, std::stringbuf& sb)  = 0;
    virtual void subCaseEnd(const TestCase& tc, std::stringbuf& sb, const TestContext& ctx,
                            int type)                                  = 0;
    virtual void testEnd(const TestContext& tc)                        = 0;
 
    static IReporter* create(const std::string& name, UnitTest& ut);
 
    IReporter(UnitTest& ut) : ut(ut) {}
 
protected:
    UnitTest& ut;
};
 
enum TestType { test_case = 1, sub_case = 1 << 1, bench = 1 << 2, fuzz_test = 1 << 3 };
 
namespace detail {
 
struct regTest {
    explicit regTest(const TestCase& tc, TestType type = test_case);
};
 
struct regReporter {
    explicit regReporter(IReporter*);
};
}  // namespace detail
 
 
class CombinationalTest {
public:
    CombinationalTest(std::function<void()> func) : func(func) {}
    std::function<void()> func;
 
    template <typename T>
    void operator()(T& arg) {
        arg.reset();
        for (size_t i = 0; i < arg.size(); ++i, ++arg) {
            func();
        }
    }
 
    template <typename T, typename... Args>
    void operator()(T& arg, Args&... args) {
        arg.reset();
        for (size_t i = 0; i < arg.size(); ++i, ++arg) {
            operator()(args...);
        }
    }
};
 
 
template <typename T>
class TestArgs {
public:
    TestArgs(std::initializer_list<T> args) : args(args) {}
    std::vector<T> args;
 
    operator T() const { return args[index]; }
    TestArgs& operator++() {
        index++;
        return *this;
    }
    size_t size() const { return args.size(); }
    void   reset() { index = 0; }
 
private:
    int index = 0;
};
 
 
class Decorator {
public:
    // Called when the test registered, return true can block the test registering
    virtual bool onStartup(const TestCase&) { return false; }
 
    // Called when the test executing, return true can block the test execution
    virtual bool onExecution(const TestCase&) { return false; }
 
    // Called on each assertion, return true can skip the assertion
    virtual bool onAssertion() { return false; }
 
    // Called when the test finished, return true means the test containing changes
    virtual bool onFinish(const TestCase&, TestContext&) { return false; }
};
 
Decorator* skip(bool isSkip = true);
Decorator* timeout(float timeout = 0.1f);  // in seconds
Decorator* may_fail(bool isMayFail = true);
Decorator* should_fail(bool isShouldFail = true);
 
}  // namespace zeroerr
 
ZEROERR_SUPPRESS_COMMON_WARNINGS_POP