testrunner.h

#ifndef WREPORT_TESTSRUNNER_H
#define WREPORT_TESTSRUNNER_H
 
#include <string>
#include <vector>
#include <functional>
#include <memory>
 
namespace wreport {
 
namespace term {
struct Terminal;
}
 
namespace 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;
 
    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& test_case, const TestCaseResult& test_case_result) { return true; }
 
    virtual void test_case_end(const TestCase& test_case, const TestCaseResult& test_case_result) {}
 
    virtual bool test_method_begin(const TestMethod& test_method, const TestMethodResult& test_method_result) { return true; }
 
    virtual void test_method_end(const TestMethod& test_method, const TestMethodResult& test_method_result) {}
};
 
struct FilteringTestController : public TestController
{
    std::string allowlist;
 
    std::string blocklist;
 
    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;
 
    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;
 
    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);
};
 
}
}
#endif