testrunner.h

#ifndef WREPORT_TESTSRUNNER_H
#define WREPORT_TESTSRUNNER_H
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace wreport::term {
struct Terminal;
}
 
namespace wreport::tests {
 
struct TestFailed;
struct TestStack;
struct TestCase;
struct TestMethod;

struct TestMethodResult
{
    std::string test_case;

    std::string test_method;

    std::string error_message;

    std::shared_ptr<TestStack> error_stack;

    std::string exception_typeid;

    bool skipped = false;

    std::string skipped_reason;

    unsigned long long elapsed_ns = 0;
 
    TestMethodResult(const std::string& test_case_,
                     const std::string& test_method_)
        : test_case(test_case_), test_method(test_method_)
    {
    }
 
    void set_failed(TestFailed& e);
 
    void set_exception(std::exception& e)
    {
        error_message = e.what();
        if (error_message.empty())
            error_message =
                "test threw an exception with an empty error message";
        exception_typeid = typeid(e).name();
    }
 
    void set_unknown_exception() { error_message = "unknown exception caught"; }
 
    void set_setup_exception(std::exception& e)
    {
        error_message = "[setup failed: ";
        error_message += e.what();
        error_message += "]";
    }
 
    void set_teardown_exception(std::exception& e)
    {
        error_message = "[teardown failed: ";
        error_message += e.what();
        error_message += "]";
    }
 
    bool is_success() const { return error_message.empty(); }
 
    void print_failure_details(FILE* out) const;
};

struct TestCaseResult
{
    std::string test_case;
    std::vector<TestMethodResult> methods;
    std::string fail_setup;
    std::string fail_teardown;
    bool skipped = false;
 
    explicit TestCaseResult(const std::string& test_case_)
        : test_case(test_case_)
    {
    }
 
    void set_setup_failed()
    {
        fail_setup = "test case setup method threw an unknown exception";
    }
 
    void set_setup_failed(std::exception& e)
    {
        fail_setup = "test case setup method threw an exception: ";
        fail_setup += e.what();
    }
 
    void set_teardown_failed()
    {
        fail_teardown = "test case teardown method threw an unknown exception";
    }
 
    void set_teardown_failed(std::exception& e)
    {
        fail_teardown = "test case teardown method threw an exception: ";
        fail_teardown += e.what();
    }
 
    void add_test_method(TestMethodResult&& e)
    {
        methods.emplace_back(std::move(e));
    }
 
    bool is_success() const
    {
        if (!fail_setup.empty() || !fail_teardown.empty())
            return false;
        for (const auto& m : methods)
            if (!m.is_success())
                return false;
        return true;
    }
 
    unsigned long long elapsed_ns() const;
};

struct TestController
{
    virtual ~TestController() {}

    virtual bool test_case_begin(const TestCase&, const TestCaseResult&)
    {
        return true;
    }

    virtual void test_case_end(const TestCase&, const TestCaseResult&) {}

    virtual bool test_method_begin(const TestMethod&, const TestMethodResult&)
    {
        return true;
    }

    virtual void test_method_end(const TestMethod&, const TestMethodResult&) {}
};

struct FilteringTestController : public TestController
{
    std::string allowlist = std::string();

    std::string blocklist = std::string();
 
    bool test_method_should_run(const std::string& fullname) const;
};

struct SimpleTestController : public FilteringTestController
{
    wreport::term::Terminal& output;
 
    SimpleTestController(wreport::term::Terminal& output);
 
    bool test_case_begin(const TestCase& test_case,
                         const TestCaseResult& test_case_result) override;
    void test_case_end(const TestCase& test_case,
                       const TestCaseResult& test_case_result) override;
    bool test_method_begin(const TestMethod& test_method,
                           const TestMethodResult& test_method_result) override;
    void test_method_end(const TestMethod& test_method,
                         const TestMethodResult& test_method_result) override;
};

struct VerboseTestController : public FilteringTestController
{
    wreport::term::Terminal& output;
 
    VerboseTestController(wreport::term::Terminal& output);
 
    bool test_case_begin(const TestCase& test_case,
                         const TestCaseResult& test_case_result) override;
    void test_case_end(const TestCase& test_case,
                       const TestCaseResult& test_case_result) override;
    bool test_method_begin(const TestMethod& test_method,
                           const TestMethodResult& test_method_result) override;
    void test_method_end(const TestMethod& test_method,
                         const TestMethodResult& test_method_result) override;
};

struct TestRegistry
{
    std::vector<TestCase*> entries = std::vector<TestCase*>();

    void register_test_case(TestCase& test_case);

    void iterate_test_methods(
        std::function<void(const TestCase&, const TestMethod&)>);

    std::vector<TestCaseResult> run_tests(TestController& controller);

    static TestRegistry& get();
};
 
struct TestResultStats
{
    const std::vector<TestCaseResult>& results;
    unsigned methods_ok        = 0;
    unsigned methods_failed    = 0;
    unsigned methods_skipped   = 0;
    unsigned test_cases_ok     = 0;
    unsigned test_cases_failed = 0;
    bool success               = false;
    bool skipped               = false;
 
    TestResultStats(const std::vector<TestCaseResult>& results);
 
    void print_results(wreport::term::Terminal& out);
    void print_stats(wreport::term::Terminal& out);
    void print_summary(wreport::term::Terminal& out);
};
 
} // namespace wreport::tests
#endif