match.h

//
// Copyright (c) 2013-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// 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)
//
 
#ifndef BEAST_UNIT_TEST_MATCH_HPP
#define BEAST_UNIT_TEST_MATCH_HPP
 
#include <xrpl/beast/unit_test/suite_info.h>
 
#include <string>
 
namespace beast {
namespace unit_test {
 
// Predicate for implementing matches
class selector
{
public:
    enum mode_t {
        // Run all tests except manual ones
        all,
 
        // Run tests that match in any field
        automatch,
 
        // Match on suite
        suite,
 
        // Match on library
        library,
 
        // Match on module (used internally)
        module,
 
        // Match nothing (used internally)
        none
    };
 
private:
    mode_t mode_;
    std::string pat_;
    std::string library_;
 
public:
    template <class = void>
    explicit selector(mode_t mode, std::string const& pattern = "");
 
    template <class = void>
    bool
    operator()(suite_info const& s);
};
 
//------------------------------------------------------------------------------
 
template <class>
selector::selector(mode_t mode, std::string const& pattern)
    : mode_(mode), pat_(pattern)
{
    if (mode_ == automatch && pattern.empty())
        mode_ = all;
}
 
template <class>
bool
selector::operator()(suite_info const& s)
{
    switch (mode_)
    {
        case automatch:
            // suite or full name
            if (s.name() == pat_ || s.full_name() == pat_)
            {
                mode_ = none;
                return true;
            }
 
            // check module
            if (pat_ == s.module())
            {
                mode_ = module;
                library_ = s.library();
                return !s.manual();
            }
 
            // check library
            if (pat_ == s.library())
            {
                mode_ = library;
                return !s.manual();
            }
 
            // check start of name
            if (s.name().starts_with(pat_) || s.full_name().starts_with(pat_))
            {
                // Don't change the mode so that the partial pattern can match
                // more than once
                return !s.manual();
            }
 
            return false;
 
        case suite:
            return pat_ == s.name();
 
        case module:
            return pat_ == s.module() && !s.manual();
 
        case library:
            return pat_ == s.library() && !s.manual();
 
        case none:
            return false;
 
        case all:
        default:
            break;
    };
 
    return !s.manual();
}
 
//------------------------------------------------------------------------------
 
// Utility functions for producing predicates to select suites.
 
inline selector
match_auto(std::string const& name)
{
    return selector(selector::automatch, name);
}
 
inline selector
match_all()
{
    return selector(selector::all);
}
 
inline selector
match_suite(std::string const& name)
{
    return selector(selector::suite, name);
}
 
inline selector
match_library(std::string const& name)
{
    return selector(selector::library, name);
}
 
}  // namespace unit_test
}  // namespace beast
 
#endif