They're horribly outdated.

Tags

Motivation

There are many reasons to tag a test or context:

• Hiding tests.
• Marking tests type: e.g. benchmark, unit, integration. Or marking a test as slow.
• Providing an alternate hierarchy to the default context.

Different tags may be defined in different ways. For example, combining the hidden tag at different points in the hierarchy would flatten them
into one hidden tag.

A hierarchical tag would concatenate the tags into one compound tag.

The user should be able to specify which tags are mandatory, and have this checked by the type system.

Implementation

By default Suite is a type aliasf for TaggedSuite<>. TaggedSuite would take a variadic list of mandatory tag types. The constructor would take the variadic mandatory tags from the constructor + a variadic list of tags that are optional. Tags should derive from a virtual base TagBase.
They can be moved into a unique_ptr to erase the type.

The signature of context(...) would look like:

template<typename Tag>
using IsTag = enable_if_t<is_base_of<TagBase, Tag>::value>*;

template<
    typename Tag,
    typename... Args,
    enable_if_t<is_base_of<TagBase, Tag>::value>* = nullptr
>
auto context(Tag tag, Args&&...);

template<
    typename Fixture,
    typename... Args,
    enable_if_t< ! is_base_of<TagBase, Fixture>::value>* = nullptr
>
auto context(Functor tag, Args&&...);

TagBase would look like:

template<typename Tag>
struct TagBase {
    virtual ~TagBase() {}
    virtual unique_ptr<TagBase> product(vector<Tag> tagHierarchy) = 0;
    virtual string type() = 0;
    virtual string value() = 0;
};

Tags would be matched via --tag <type:regexp>.

Change the license to boost and include a copy of it at the start of every source file.

The idea is that where you'd write if (someFailureConditon) throw..., you could write if (canThrow(someFailureCondition)) throw.... In production, canThrow would always return it's argument. In the test harness, it will fail the 1st successful canThrow, then the next and so on until nothing fails. It wouldn't expect tests to pass (except on the last run), but expect them not to crash.