runner.h

// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
 
#pragma once
 
#include <xrpl/beast/unit_test/suite_info.h>
 
#include <boost/assert.hpp>
 
#include <mutex>
#include <string>
 
namespace beast::unit_test {

class Runner
{
    std::string arg_;
    bool default_ = false;
    bool failed_ = false;
    bool cond_ = false;
    std::recursive_mutex mutex_;
 
public:
    Runner() = default;
    virtual ~Runner() = default;
    Runner(Runner const&) = delete;
    Runner&
    operator=(Runner const&) = delete;

    void
    arg(std::string const& s)
    {
        arg_ = s;
    }

    [[nodiscard]] std::string const&
    arg() const
    {
        return arg_;
    }

    template <class = void>
    bool
    run(SuiteInfo const& s);

    template <class FwdIter>
    bool
    run(FwdIter first, FwdIter last);

    template <class FwdIter, class Pred>
    bool
    runIf(FwdIter first, FwdIter last, Pred pred = Pred{});

    template <class SequenceContainer>
    bool
    runEach(SequenceContainer const& c);

    template <class SequenceContainer, class Pred>
    bool
    runEachIf(SequenceContainer const& c, Pred pred = Pred{});
 
protected:
    virtual void
    onSuiteBegin(SuiteInfo const&)
    {
    }

    virtual void
    onSuiteEnd()
    {
    }

    virtual void
    onCaseBegin(std::string const&)
    {
    }

    virtual void
    onCaseEnd()
    {
    }

    virtual void
    onPass()
    {
    }

    virtual void
    onFail(std::string const&)
    {
    }

    virtual void
    onLog(std::string const&)
    {
    }
 
private:
    friend class Suite;
 
    // Start a new testcase.
    template <class = void>
    void
    testcase(std::string const& name);
 
    template <class = void>
    void
    pass();
 
    template <class = void>
    void
    fail(std::string const& reason);
 
    template <class = void>
    void
    log(std::string const& s);
};
 
//------------------------------------------------------------------------------
 
template <class>
bool
Runner::run(SuiteInfo const& s)
{
    // Enable 'default' testcase
    default_ = true;
    failed_ = false;
    onSuiteBegin(s);
    s.run(*this);
    // Forgot to call pass or fail.
    BOOST_ASSERT(cond_);
    onCaseEnd();
    onSuiteEnd();
    return failed_;
}
 
template <class FwdIter>
bool
Runner::run(FwdIter first, FwdIter last)
{
    bool failed(false);
    for (; first != last; ++first)
        failed = run(*first) || failed;
    return failed;
}
 
template <class FwdIter, class Pred>
bool
Runner::runIf(FwdIter first, FwdIter last, Pred pred)
{
    bool failed(false);
    for (; first != last; ++first)
    {
        if (pred(*first))
            failed = run(*first) || failed;
    }
    return failed;
}
 
template <class SequenceContainer>
bool
Runner::runEach(SequenceContainer const& c)
{
    bool failed(false);
    for (auto const& s : c)
        failed = run(s) || failed;
    return failed;
}
 
template <class SequenceContainer, class Pred>
bool
Runner::runEachIf(SequenceContainer const& c, Pred pred)
{
    bool failed(false);
    for (auto const& s : c)
    {
        if (pred(s))
            failed = run(s) || failed;
    }
    return failed;
}
 
template <class>
void
Runner::testcase(std::string const& name)
{
    std::scoped_lock const lock(mutex_);
    // Name may not be empty
    BOOST_ASSERT(default_ || !name.empty());
    // Forgot to call pass or fail
    BOOST_ASSERT(default_ || cond_);
    if (!default_)
        onCaseEnd();
    default_ = false;
    cond_ = false;
    onCaseBegin(name);
}
 
template <class>
void
Runner::pass()
{
    std::scoped_lock const lock(mutex_);
    if (default_)
        testcase("");
    onPass();
    cond_ = true;
}
 
template <class>
void
Runner::fail(std::string const& reason)
{
    std::scoped_lock const lock(mutex_);
    if (default_)
        testcase("");
    onFail(reason);
    failed_ = true;
    cond_ = true;
}
 
template <class>
void
Runner::log(std::string const& s)
{
    std::scoped_lock const lock(mutex_);
    if (default_)
        testcase("");
    onLog(s);
}
 
}  // namespace beast::unit_test