Reporter.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
// 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 <iostream>
#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;
    };
 
    namespace detail
    {
        template <print_iterator OutIter>
        OutIter stringify_stacktrace(OutIter out, const Stacktrace& stacktrace)
        {
            if (!stacktrace.empty())
            {
                out = format::format_to(
                    std::move(out),
                    "Stacktrace:\n");
                out = mimicpp::print(
                    std::move(out),
                    stacktrace);
            }
 
            return out;
        }
 
        [[nodiscard]]
        inline StringT stringify_no_match_report(const CallReport& call, const std::span<const MatchReport> matchReports)
        {
            StringStreamT ss{};
            ss << "No match for ";
            mimicpp::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)
                {
                    mimicpp::print(
                        std::ostreambuf_iterator{ss},
                        report);
                    ss << "\n";
                }
            }
 
            stringify_stacktrace(
                std::ostreambuf_iterator{ss},
                call.stacktrace);
 
            return std::move(ss).str();
        }
 
        [[nodiscard]]
        inline StringT stringify_inapplicable_match_report(const CallReport& call, const std::span<const MatchReport> matchReports)
        {
            StringStreamT ss{};
            ss << "No applicable match for ";
            mimicpp::print(
                std::ostreambuf_iterator{ss},
                call);
            ss << "\n";
 
            ss << "Tested expectations:\n";
            for (const auto& report : matchReports)
            {
                mimicpp::print(
                    std::ostreambuf_iterator{ss},
                    report);
                ss << "\n";
            }
 
            stringify_stacktrace(
                std::ostreambuf_iterator{ss},
                call.stacktrace);
 
            return std::move(ss).str();
        }
 
        [[nodiscard]]
        inline StringT stringify_report(const CallReport& call, const MatchReport& matchReport)
        {
            StringStreamT ss{};
            ss << "Found match for ";
            mimicpp::print(
                std::ostreambuf_iterator{ss},
                call);
            ss << "\n";
 
            mimicpp::print(
                std::ostreambuf_iterator{ss},
                matchReport);
            ss << "\n";
 
            stringify_stacktrace(
                std::ostreambuf_iterator{ss},
                call.stacktrace);
 
            return std::move(ss).str();
        }
 
        [[nodiscard]]
        inline StringT stringify_unfulfilled_expectation(const ExpectationReport& expectationReport)
        {
            StringStreamT ss{};
            ss << "Unfulfilled expectation:\n";
            mimicpp::print(
                std::ostreambuf_iterator{ss},
                expectationReport);
            ss << "\n";
 
            return std::move(ss).str();
        }
 
        [[nodiscard]]
        inline StringT stringify_unhandled_exception(
            const CallReport& call,
            const ExpectationReport& expectationReport,
            const std::exception_ptr& exception)
        {
            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";
            mimicpp::print(
                std::ostreambuf_iterator{ss},
                expectationReport);
            ss << "\n";
 
            ss << "For ";
            mimicpp::print(
                std::ostreambuf_iterator{ss},
                call);
            ss << "\n";
 
            return std::move(ss).str();
        }
    }

    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
        {
            send_fail(
                detail::stringify_no_match_report(call, matchReports));
        }
 
        [[noreturn]]
        void report_inapplicable_matches(const CallReport call, const std::vector<MatchReport> matchReports) override
        {
            send_fail(
                detail::stringify_inapplicable_match_report(call, matchReports));
        }
 
        void report_full_match(const CallReport call, const MatchReport matchReport) noexcept override
        {
            send_success(
                detail::stringify_report(call, matchReport));
        }
 
        void report_unfulfilled_expectation(const ExpectationReport expectationReport) override
        {
            if (0 == std::uncaught_exceptions())
            {
                send_fail(
                    detail::stringify_unfulfilled_expectation(expectationReport));
            }
        }
 
        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
        {
            send_warning(
                detail::stringify_unhandled_exception(call, expectationReport, exception));
        }
 
    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:
        [[nodiscard]]
        explicit DefaultReporter(std::ostream* out = nullptr) noexcept
            : m_Out{out}
        {
        }
 
        [[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 auto msg = detail::stringify_no_match_report(call, matchReports);
            if (m_Out)
            {
                *m_Out << msg << '\n';
            }
 
            const std::source_location loc{call.fromLoc};
            throw UnmatchedCallT{
                msg,
                {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 auto msg = detail::stringify_inapplicable_match_report(call, matchReports);
            if (m_Out)
            {
                *m_Out << msg << '\n';
            }
 
            const std::source_location loc{call.fromLoc};
            throw UnmatchedCallT{
                msg,
                {std::move(call), std::move(matchReports)},
                loc
            };
        }
 
        void report_full_match(
            [[maybe_unused]] const CallReport call,
            [[maybe_unused]] const MatchReport matchReport) noexcept override
        {
            assert(MatchResult::full == evaluate_match_report(matchReport));
        }
 
        void report_unfulfilled_expectation(
            ExpectationReport expectationReport) override
        {
            if (0 == std::uncaught_exceptions())
            {
                const auto msg = detail::stringify_unfulfilled_expectation(expectationReport);
                if (m_Out)
                {
                    *m_Out << msg << '\n';
                }
 
                throw UnfulfilledExpectationT{
                    msg,
                    std::move(expectationReport)};
            }
        }
 
        void report_error(const StringT message) override
        {
            if (0 == std::uncaught_exceptions())
            {
                if (m_Out)
                {
                    *m_Out << message << '\n';
                }
 
                throw Error{message};
            }
        }
 
        void report_unhandled_exception(
            const CallReport call,
            const ExpectationReport expectationReport,
            const std::exception_ptr exception) override
        {
            if (m_Out)
            {
                *m_Out << detail::stringify_unhandled_exception(call, expectationReport, exception)
                       << '\n';
            }
        }
 
    private:
        std::ostream* m_Out;
    };

}
 
namespace mimicpp::detail
{
    [[nodiscard]]
    inline std::unique_ptr<IReporter>& get_reporter() noexcept
    {
        static std::unique_ptr<IReporter> reporter{
            std::make_unique<DefaultReporter>(&std::cerr)};
        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