diff options
Diffstat (limited to 'boost/beast/_experimental/unit_test/match.hpp')
-rw-r--r-- | boost/beast/_experimental/unit_test/match.hpp | 177 |
1 files changed, 177 insertions, 0 deletions
diff --git a/boost/beast/_experimental/unit_test/match.hpp b/boost/beast/_experimental/unit_test/match.hpp new file mode 100644 index 0000000000..0168af802e --- /dev/null +++ b/boost/beast/_experimental/unit_test/match.hpp @@ -0,0 +1,177 @@ +// +// Copyright (c) 2016-2019 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) +// +// Official repository: https://github.com/boostorg/beast +// + +#ifndef BOOST_BEAST_UNIT_TEST_MATCH_HPP +#define BOOST_BEAST_UNIT_TEST_MATCH_HPP + +#include <boost/beast/_experimental/unit_test/suite_info.hpp> +#include <string> + +namespace boost { +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(); + } + + 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: + // fall through + break; + }; + + return ! s.manual(); +} + +//------------------------------------------------------------------------------ + +// Utility functions for producing predicates to select suites. + +/** Returns a predicate that implements a smart matching rule. + The predicate checks the suite, module, and library fields of the + suite_info in that order. When it finds a match, it changes modes + depending on what was found: + + If a suite is matched first, then only the suite is selected. The + suite may be marked manual. + + If a module is matched first, then only suites from that module + and library not marked manual are selected from then on. + + If a library is matched first, then only suites from that library + not marked manual are selected from then on. + +*/ +inline +selector +match_auto(std::string const& name) +{ + return selector(selector::automatch, name); +} + +/** Return a predicate that matches all suites not marked manual. */ +inline +selector +match_all() +{ + return selector(selector::all); +} + +/** Returns a predicate that matches a specific suite. */ +inline +selector +match_suite(std::string const& name) +{ + return selector(selector::suite, name); +} + +/** Returns a predicate that matches all suites in a library. */ +inline +selector +match_library(std::string const& name) +{ + return selector(selector::library, name); +} + +} // unit_test +} // beast +} // boost + +#endif |