Reporter.hpp

Go to the documentation of this file.

// //          Copyright Dominic (DNKpp) Koepke 2024 - 2024.
// // Distributed under the Boost Software License, Version 1.0.
// //    (See accompanying file LICENSE_1_0.txt or copy at
// //          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef MIMICPP_REPORTER_HPP
#define MIMICPP_REPORTER_HPP
 
#pragma once
 
#include "mimic++/Call.hpp"
#include "mimic++/Fwd.hpp"
#include "mimic++/Printer.hpp"
#include "mimic++/Reports.hpp"
 
#include <algorithm>
#include <cassert>
#include <exception>
#include <functional>
#include <memory>
#include <optional>
#include <ranges>
#include <vector>
 
namespace mimicpp
{
    class IReporter
    {
    public:
        virtual ~IReporter() = default;
 
        [[noreturn]]
        virtual void report_no_matches(
            CallReport call,
            std::vector<MatchReport> matchReports
        ) = 0;
 
        [[noreturn]]
        virtual void report_inapplicable_matches(
            CallReport call,
            std::vector<MatchReport> matchReports
        ) = 0;
 
        virtual void report_full_match(
            CallReport call,
            MatchReport matchReport
        ) noexcept = 0;
 
        virtual void report_unfulfilled_expectation(
            ExpectationReport expectationReport
        ) = 0;
 
        virtual void report_error(StringT message) = 0;
 
        virtual void report_unhandled_exception(
            CallReport call,
            ExpectationReport expectationReport,
            std::exception_ptr exception
        ) = 0;
 
    protected:
        [[nodiscard]]
        IReporter() = default;
 
        IReporter(const IReporter&) = default;
        IReporter& operator =(const IReporter&) = default;
        IReporter(IReporter&&) = default;
        IReporter& operator =(IReporter&&) = default;
    };
 
    template <typename Data = std::nullptr_t>
    class Error final
        : public std::runtime_error
    {
    public:
        [[nodiscard]]
        explicit Error(
            const std::string& what,
            Data&& data = Data{},
            const std::source_location& loc = std::source_location::current()
        )
            : std::runtime_error{what},
            m_Data{std::move(data)},
            m_Loc{loc}
        {
        }
 
        [[nodiscard]]
        const Data& data() const noexcept
        {
            return m_Data;
        }
 
        [[nodiscard]]
        const std::source_location& where() const noexcept
        {
            return m_Loc;
        }
 
    private:
        Data m_Data;
        std::source_location m_Loc;
    };
 
    template <
        std::invocable<const StringT&> auto successReporter,
        std::invocable<const StringT&> auto warningReporter,
        std::invocable<const StringT&> auto failReporter
    >
    class BasicReporter
        : public IReporter
    {
    public:
        [[noreturn]]
        void report_no_matches(const CallReport call, const std::vector<MatchReport> matchReports) override
        {
            StringStreamT ss{};
            ss << "No match for ";
            print(
                std::ostreambuf_iterator{ss},
                call);
            ss << "\n";
 
            if (std::ranges::empty(matchReports))
            {
                ss << "No expectations available.\n";
            }
            else
            {
                format::format_to(
                    std::ostreambuf_iterator{ss},
                    "{} available expectation(s):\n",
                    std::ranges::size(matchReports));
 
                for (const auto& report : matchReports)
                {
                    print(
                        std::ostreambuf_iterator{ss},
                        report);
                    ss << "\n";
                }
            }
 
            send_fail(std::move(ss).str());
        }
 
        [[noreturn]]
        void report_inapplicable_matches(const CallReport call, const std::vector<MatchReport> matchReports) override
        {
            StringStreamT ss{};
            ss << "No applicable match for ";
            print(
                std::ostreambuf_iterator{ss},
                call);
            ss << "\n";
 
            ss << "Tested expectations:\n";
            for (const auto& report : matchReports)
            {
                print(
                    std::ostreambuf_iterator{ss},
                    report);
                ss << "\n";
            }
 
            send_fail(std::move(ss).str());
        }
 
        void report_full_match(const CallReport call, const MatchReport matchReport) noexcept override
        {
            StringStreamT ss{};
            ss << "Found match for ";
            print(
                std::ostreambuf_iterator{ss},
                call);
            ss << "\n";
 
            print(
                std::ostreambuf_iterator{ss},
                matchReport);
            ss << "\n";
 
            send_success(std::move(ss).str());
        }
 
        void report_unfulfilled_expectation(const ExpectationReport expectationReport) override
        {
            if (0 == std::uncaught_exceptions())
            {
                StringStreamT ss{};
                ss << "Unfulfilled expectation:\n";
                print(
                    std::ostreambuf_iterator{ss},
                    expectationReport);
                ss << "\n";
 
                send_fail(std::move(ss).str());
            }
        }
 
        void report_error(const StringT message) override
        {
            if (0 == std::uncaught_exceptions())
            {
                send_fail(message);
            }
        }
 
        void report_unhandled_exception(
            const CallReport call,
            const ExpectationReport expectationReport,
            const std::exception_ptr exception
        ) override
        {
            StringStreamT ss{};
            ss << "Unhandled exception: ";
 
            try
            {
                std::rethrow_exception(exception);
            }
            catch (const std::exception& e)
            {
                ss << "what: "
                    << e.what()
                    << "\n";
            }
            catch (...)
            {
                ss << "Unknown exception type.\n";
            }
 
            ss << "while checking expectation:\n";
            print(
                std::ostreambuf_iterator{ss},
                expectationReport);
            ss << "\n";
 
            ss << "For ";
            print(
                std::ostreambuf_iterator{ss},
                call);
            ss << "\n";
 
            send_warning(std::move(ss).str());
        }
 
    private:
        void send_success(const StringT& msg)
        {
            std::invoke(successReporter, msg);
        }
 
        void send_warning(const StringT& msg)
        {
            std::invoke(warningReporter, msg);
        }
 
        [[noreturn]]
        void send_fail(const StringT& msg)
        {
            // GCOVR_EXCL_START
            std::invoke(failReporter, msg);
            unreachable();
            // GCOVR_EXCL_STOP
        }
    };
 
    using UnmatchedCallT = Error<std::tuple<CallReport, std::vector<MatchReport>>>;
    using UnfulfilledExpectationT = Error<ExpectationReport>;
 
    class DefaultReporter final
        : public IReporter
    {
    public:
        [[noreturn]]
        void report_no_matches(
            CallReport call,
            std::vector<MatchReport> matchReports
        ) override
        {
            assert(
                std::ranges::all_of(
                    matchReports,
                    std::bind_front(std::equal_to{}, MatchResult::none),
                    &evaluate_match_report));
 
            const std::source_location loc{call.fromLoc};
            throw UnmatchedCallT{
                "No match found.",
                {std::move(call), std::move(matchReports)},
                loc
            };
        }
 
        [[noreturn]]
        void report_inapplicable_matches(
            CallReport call,
            std::vector<MatchReport> matchReports
        ) override
        {
            assert(
                std::ranges::all_of(
                    matchReports,
                    std::bind_front(std::equal_to{}, MatchResult::inapplicable),
                    &evaluate_match_report));
 
            const std::source_location loc{call.fromLoc};
            throw UnmatchedCallT{
                "No applicable match found.",
                {std::move(call), std::move(matchReports)},
                loc
            };
        }
 
        void report_full_match(
            [[maybe_unused]] CallReport call,
            [[maybe_unused]] MatchReport matchReport
        ) noexcept override
        {
            assert(MatchResult::full == evaluate_match_report(matchReport));
        }
 
        void report_unfulfilled_expectation(
            ExpectationReport expectationReport
        ) override
        {
            if (0 == std::uncaught_exceptions())
            {
                throw UnfulfilledExpectationT{
                    "Expectation is unfulfilled.",
                    std::move(expectationReport)
                };
            }
        }
 
        void report_error(StringT message) override
        {
            if (0 == std::uncaught_exceptions())
            {
                throw Error{message};
            }
        }
 
        void report_unhandled_exception(
            [[maybe_unused]] CallReport call,
            [[maybe_unused]] ExpectationReport expectationReport,
            [[maybe_unused]] std::exception_ptr exception
        ) override
        {
        }
    };
 
}
 
namespace mimicpp::detail
{
    [[nodiscard]]
    inline std::unique_ptr<IReporter>& get_reporter() noexcept
    {
        static std::unique_ptr<IReporter> reporter{
            std::make_unique<DefaultReporter>()
        };
        return reporter;
    }
 
    [[noreturn]]
    inline void report_no_matches(
        CallReport callReport,
        std::vector<MatchReport> matchReports
    )
    {
        get_reporter()
            // GCOVR_EXCL_START
            ->report_no_matches(
                // GCOVR_EXCL_STOP
                std::move(callReport),
                std::move(matchReports));
 
        // GCOVR_EXCL_START
        // ReSharper disable once CppUnreachableCode
        unreachable();
        // GCOVR_EXCL_STOP
    }
 
    [[noreturn]]
    inline void report_inapplicable_matches(
        CallReport callReport,
        std::vector<MatchReport> matchReports
    )
    {
        get_reporter()
            // GCOVR_EXCL_START
            ->report_inapplicable_matches(
                // GCOVR_EXCL_STOP
                std::move(callReport),
                std::move(matchReports));
 
        // GCOVR_EXCL_START
        // ReSharper disable once CppUnreachableCode
        unreachable();
        // GCOVR_EXCL_STOP
    }
 
    inline void report_full_match(
        CallReport callReport,
        MatchReport matchReport
    ) noexcept
    {
        get_reporter()
            ->report_full_match(
                std::move(callReport),
                std::move(matchReport));
    }
 
    inline void report_unfulfilled_expectation(
        ExpectationReport expectationReport
    )
    {
        get_reporter()
            ->report_unfulfilled_expectation(std::move(expectationReport));
    }
 
    inline void report_error(StringT message)
    {
        get_reporter()
            ->report_error(std::move(message));
    }
 
    inline void report_unhandled_exception(
        CallReport callReport,
        ExpectationReport expectationReport,
        const std::exception_ptr& exception
    )
    {
        get_reporter()
            ->report_unhandled_exception(
                std::move(callReport),
                std::move(expectationReport),
                exception);
    }
}
 
namespace mimicpp
{
    template <std::derived_from<IReporter> T, typename... Args>
        requires std::constructible_from<T, Args...>
    void install_reporter(Args&&... args)  // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        detail::get_reporter() = std::make_unique<T>(
            std::forward<Args>(args)...);
    }
 
    namespace detail
    {
        template <typename T>
        class ReporterInstaller
        {
        public:
            template <typename... Args>
            explicit ReporterInstaller(Args&&... args)
            {
                install_reporter<T>(
                    std::forward<Args>(args)...);
            }
        };
    }
 
}
 
#endif