Better support for testing exception

[AlexisWilke]

Description

I was thinking I could just check the what() string of an exception in Catch2. The fact is I had to write my own Matcher.

It seems to me that since a fairly standard exception is expected to have a what() returning a string which we could match, that it would make sense to offer such a generic Matcher.

Example Matcher

I wrote my own std::exception Matcher which looks as follow. Using it with CATCH_REQUIRE_THROWS_MATCHES() is very simple:

    CATCH_REQUIRE_THROWS_MATCHES(std::make_shared<advgetopt::getopt>(options_environment, sub_argc, sub_argv)
                , advgetopt::getopt_exception_logic
                , Catch::Matchers::ExceptionMessage(
                          "section \"invalid::name\" includes a section separator (::) in \""
                        + options_filename
                        + "\". We only support one level."));

I think this is much cleaner than having to have a toString() or and operator std::string() in your exceptions. This is much more generic.

namespace Catch
{
namespace Matchers
{


class ExceptionWatcher
    : public MatcherBase<std::exception>
{
public:
    ExceptionWatcher(std::string const & expected_message)
        : m_expected_message(expected_message)
    {
    }

    /** \brief Check whether we got a match.
     *
     * This function compares the expected string with the actual exception
     * what() output.
     */
    bool match(std::exception const & e) const override
    {
        return e.what() == m_expected_message;
    }

    /** \brief Describe this matcher.
     *
     * This function produces a string describing what this matcher does.
     *
     * \return The description of this matcher.
     */
    virtual std::string describe() const override
    {
        return "compare the exception what() message with \""
             + m_expected_message
             + "\".";
    }

private:
    std::string     m_expected_message = std::string();
};


inline ExceptionWatcher ExceptionMessage(std::string const & expeted_message)
{
    return ExceptionWatcher(expeted_message);
}



}
// Matchers namespace
}
// Catch namespace

Cons?

I know some people like to create their own exceptions from scratch, although I've seen many projects and more and more I see exceptions being properly derived from std::runtime_error or std::logic_error. So I have hope that having such a generic Watcher in Catch2 will be considered. Maybe even have a <string>_e which automatically converts said string to that generic exception Watcher.

So in effect I don't personally see any cons (outside of having to maintain one more class and maybe a few more functions.)

Also I was wondering how I could have access to all the string Watchers functionality (i.e. StartWith, EndsWith, Contains... instead of just return e.what() == m_expected_message; because that can prove difficult when a exception message contains a run-time value.)

[horenmar]

Isn't the very basic version of what you want just REQUIRE_THROWS_WITH(expr, message)?

[AlexisWilke]

Ah, it's very close... I can verify the message but not the type of the exception, though.

I suppose I could run both:

• REQUIRE_THROWS_AS() to verify the type; and
• REQUIRE_THROWS_WITH() to check the message.