unittest.h

Go to the documentation of this file.

#pragma once
 
// libc++ offers compatibility-only transitive includes through C++20.
// Suppress those while loading our explicit dependencies, then restore the
// caller's setting. This does not change standard-library types or ABI.
#pragma push_macro("_LIBCPP_REMOVE_TRANSITIVE_INCLUDES")
#ifndef _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
#define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
#endif
 
 
#include "zeroerr/internal/config.h"
#include "zeroerr/assert.h"
 
#include "zeroerr/internal/time.h"
#include <iosfwd>
#include <functional>
#include "zeroerr/string.h"
#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
 
// The caller supplies the lambda body, so no diagnostic pragma may follow
// the lambda declarator (GCC rejects it before the opening brace).
#define SUB_CASE(...) ZEROERR_EXPAND(ZEROERR_CREATE_SUB_CASE(__VA_ARGS__))
 
#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_CAT(fixture, _zeroerr_class)), \
                                             ZEROERR_NAMEGEN(ZEROERR_CAT(fixture, _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;
 
    Duration duration;
 
    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;
    zeroerr::String     list_format     = "console";
    bool            no_color        = false;
    bool            log_to_report   = false;
    bool            show_help       = false;
    bool            invalid_args    = false;
    zeroerr::String     correct_output_path;
    zeroerr::String     reporter_name = "console";
    zeroerr::String     binary;
    // Fresh output directory for optional Clang per-test raw profiles.
    zeroerr::String     coverage_output;
    // Run collection and analysis together, like the optional fuzz mode.
    bool            run_coverage = false;
    std::vector<zeroerr::String> coverage_arguments;
    struct Filters* filters = nullptr;
};

struct TestCase {
    zeroerr::String                       name;
    zeroerr::String                       file;
    unsigned                          line;
    std::function<void(TestContext*)> func;
    std::vector<TestCase*>            subcases;
    std::vector<Decorator*>           decorators;
    bool operator<(const TestCase& rhs) const;

    TestCase(zeroerr::String name, zeroerr::String file, unsigned line, std::vector<Decorator*> decorators)
        : name(name), file(file), line(line), decorators(decorators) {}

    TestCase(zeroerr::String name, zeroerr::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(zeroerr::String name, zeroerr::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 zeroerr::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 zeroerr::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
 
#pragma pop_macro("_LIBCPP_REMOVE_TRANSITIVE_INCLUDES")