StringifyReports.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024 - 2026.
// 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_REPORTING_STRINGIFY_REPORTS_HPP
#define MIMICPP_REPORTING_STRINGIFY_REPORTS_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/printing/Format.hpp"
#include "mimic++/reporting/CallReport.hpp"
#include "mimic++/reporting/ExpectationReport.hpp"
#include "mimic++/reporting/MatchReport.hpp"
#include "mimic++/reporting/TypeReport.hpp"
#include "mimic++/utilities/Algorithm.hpp"
#include "mimic++/utilities/C++23Backports.hpp"
#include "mimic++/utilities/Stacktrace.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <algorithm>
    #include <exception>
    #include <iterator>
    #include <optional>
    #include <span>
    #include <utility>
#endif
 
namespace mimicpp::reporting::detail
{
    template <print_iterator OutIter>
    OutIter stringify_stacktrace(OutIter out, util::Stacktrace const& stacktrace)
    {
        if (!stacktrace.empty())
        {
            out = format::format_to(std::move(out), "\nStacktrace:\n");
            out = mimicpp::print(std::move(out), stacktrace);
        }
 
        return out;
    }
 
    template <print_iterator OutIter>
    OutIter stringify_call_report_arguments(OutIter out, CallReport const& call, StringViewT const linePrefix)
    {
        if (call.argDetails.empty())
        {
            return out;
        }
 
        out = std::ranges::copy(linePrefix, std::move(out)).out;
        out = format::format_to(std::move(out), "Where:\n");
 
        for (int i{};
             auto const& [type, state] : call.argDetails)
        {
            out = std::ranges::copy(linePrefix, std::move(out)).out;
            out = format::format_to(std::move(out), "\targ[{}] => ", i++);
            out = std::ranges::copy(type.name(), std::move(out)).out;
            out = format::format_to(std::move(out), ": ");
            out = std::ranges::copy(state, std::move(out)).out;
            out = format::format_to(std::move(out), "\n");
        }
 
        return out;
    }
 
    template <print_iterator OutIter>
    OutIter stringify_call_report_from(OutIter out, CallReport const& call)
    {
        out = format::format_to(std::move(out), "Call originated from ");
 
        if (!call.stacktrace.empty())
        {
            out = util::stacktrace::detail::print_entry(std::move(out), call.stacktrace, 0u);
        }
        else
        {
            out = mimicpp::print(std::move(out), call.fromLoc);
        }
        out = format::format_to(std::move(out), "\n");
 
        return out;
    }
 
    template <print_iterator OutIter>
    OutIter stringify_call_report_target(OutIter out, CallReport const& call)
    {
        out = format::format_to(
            std::move(out),
            "\tOn Target `{}` used Overload `{}`\n",
            call.target.name,
            call.target.overloadReport.name());
 
        return out;
    }
 
    template <print_iterator OutIter>
    OutIter stringify_expectation_report_from(OutIter out, ExpectationReport const& expectation)
    {
        out = format::format_to(std::move(out), "Expectation defined at ");
        out = mimicpp::print(std::move(out), expectation.from);
        out = format::format_to(std::move(out), "\n");
 
        return out;
    }
 
    template <print_iterator OutIter>
    OutIter stringify_expectation_report_target(OutIter out, ExpectationReport const& expectation)
    {
        out = format::format_to(
            std::move(out),
            "\tOf Target `{}` related to Overload `{}`\n",
            expectation.target.name,
            expectation.target.overloadReport.name());
 
        return out;
    }
 
    template <print_iterator OutIter>
    OutIter stringify_expectation_report_requirement_adherences(
        OutIter out,
        std::span<expectation::MatchResult const> const adherences,
        StringViewT const linePrefix)
    {
        if (adherences.empty())
        {
            return out;
        }
 
        out = std::ranges::copy(linePrefix, std::move(out)).out;
        out = format::format_to(std::move(out), "With Adherence(s):\n");
 
        for (auto const& addherence : adherences)
        {
            auto const& [description] = std::get<expectation::MatchSuccess>(addherence);
            if (description)
            {
                out = std::ranges::copy(linePrefix, std::move(out)).out;
                out = format::format_to(std::move(out), "  + ");
                out = std::ranges::copy(*description, std::move(out)).out;
                out = format::format_to(std::move(out), "\n");
            }
        }
 
        return out;
    }
 
    struct inapplicable_reason_printer
    {
        template <print_iterator OutIter>
        OutIter operator()([[maybe_unused]] OutIter out, [[maybe_unused]] state_applicable const& state) const
        {
            util::unreachable();
        }
 
        template <print_iterator OutIter>
        constexpr OutIter operator()(OutIter out, state_inapplicable const& state) const
        {
            auto const totalSequences = std::ranges::ssize(state.sequences)
                                      + std::ranges::ssize(state.inapplicableSequences);
            out = format::format_to(
                std::move(out),
                "it's not Head of {} Sequence(s) ({} total).\n",
                std::ranges::ssize(state.inapplicableSequences),
                totalSequences);
 
            MIMICPP_ASSERT(!state.inapplicableSequences.empty(), "Inapplicable sequences can not be empty.");
            for (auto const& sequence : state.inapplicableSequences)
            {
                MIMICPP_ASSERT(sequence.headFrom, "Head-from can not be empty.");
                out = format::format_to(std::move(out), "\t\tExpectation defined at ");
                out = mimicpp::print(std::move(out), *sequence.headFrom);
                out = format::format_to(std::move(out), " is Head of Sequence from ");
                out = mimicpp::print(std::move(out), sequence.from);
                out = format::format_to(std::move(out), "\n");
            }
 
            return out;
        }
 
        template <print_iterator OutIter>
        constexpr OutIter operator()(OutIter out, state_saturated const& state) const
        {
            out = format::format_to(
                std::move(out),
                "it's already saturated (matched {} out of {} times).\n",
                state.count,
                state.max);
 
            return out;
        }
    };
 
    template <print_iterator OutIter>
    OutIter stringify_expectation_report_requirement_violations(
        OutIter out,
        std::span<expectation::MatchResult const> const failures,
        StringViewT const linePrefix)
    {
        MIMICPP_ASSERT(!failures.empty(), "Zero requirements can never be violated.");
 
        out = std::ranges::copy(linePrefix, std::move(out)).out;
        out = format::format_to(std::move(out), "Due to Violation(s):\n");
 
        int withoutDescription{0};
        for (auto const& failure : failures)
        {
            auto const& [description] = std::get<expectation::MatchFailure>(failure);
            if (description)
            {
                out = std::ranges::copy(linePrefix, std::move(out)).out;
                out = format::format_to(std::move(out), "  - ");
                out = std::ranges::copy(*description, std::move(out)).out;
                out = format::format_to(std::move(out), "\n");
            }
            else
            {
                ++withoutDescription;
            }
        }
 
        if (0 < withoutDescription)
        {
            out = std::ranges::copy(linePrefix, std::move(out)).out;
            out = format::format_to(std::move(out), "  - ");
            out = format::format_to(
                std::move(out),
                "{} Requirement(s) failed without further description.\n",
                withoutDescription);
        }
 
        return out;
    }
 
    struct unfulfilled_reason_printer
    {
        template <print_iterator OutIter>
        OutIter operator()(OutIter out, state_applicable const& state) const
        {
            return stringify_times_state(
                std::move(out),
                state.count,
                state.min,
                state.max);
        }
 
        template <print_iterator OutIter>
        OutIter operator()(OutIter out, state_inapplicable const& state) const
        {
            return stringify_times_state(
                std::move(out),
                state.count,
                state.min,
                state.max);
        }
 
        template <print_iterator OutIter>
        OutIter operator()([[maybe_unused]] OutIter out, [[maybe_unused]] state_saturated const& state) const
        {
            util::unreachable();
        }
 
    private:
        template <print_iterator OutIter>
        static OutIter stringify_times_state(OutIter out, int const current, int const min, int const max)
        {
            const auto verbalizeValue = [](OutIter o, int const value) {
                MIMICPP_ASSERT(0 < value, "Invalid value.");
 
                switch (value)
                {
                case 1:  return format::format_to(std::move(o), "once");
                case 2:  return format::format_to(std::move(o), "twice");
                default: return format::format_to(std::move(o), "{} times", value);
                }
            };
 
            MIMICPP_ASSERT(current < min, "State doesn't denote an unsatisfied state.");
 
            out = format::format_to(std::move(out), "matching ");
 
            if (min == max)
            {
                out = format::format_to(std::move(out), "exactly ");
                out = verbalizeValue(std::move(out), min);
                out = format::format_to(std::move(out), " ");
            }
            else if (max == std::numeric_limits<int>::max())
            {
                out = format::format_to(std::move(out), "at least ");
                out = verbalizeValue(std::move(out), min);
                out = format::format_to(std::move(out), " ");
            }
            else
            {
                out = format::format_to(
                    std::move(out),
                    "between {} and {} times ",
                    min,
                    max);
            }
 
            return format::format_to(
                std::move(out),
                "was expected => requires {} further match(es).\n",
                min - current);
        }
    };
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::reporting
{
    [[nodiscard]]
    inline StringT stringify_full_match(CallReport const& call, MatchReport match)
    {
        MIMICPP_ASSERT(std::holds_alternative<state_applicable>(match.expectationReport.controlReport), "Report denotes inapplicable expectation.");
 
        StringStreamT ss{};
        ss << "Matched ";
        detail::stringify_call_report_from(std::ostreambuf_iterator{ss}, call);
        detail::stringify_call_report_target(std::ostreambuf_iterator{ss}, call);
        detail::stringify_call_report_arguments(std::ostreambuf_iterator{ss}, call, "\t");
 
        ss << "\t" << "Chose ";
        detail::stringify_expectation_report_from(std::ostreambuf_iterator{ss}, match.expectationReport);
 
        if (!match.matchResults.empty())
        {
            std::ranges::sort(
                match.matchResults,
                {},
                [](expectation::MatchResult const& m) -> auto const& { return std::get<expectation::MatchSuccess>(m).description; });
            detail::stringify_expectation_report_requirement_adherences(
                std::ostreambuf_iterator{ss},
                match.matchResults,
                "\t");
        }
        else
        {
            ss << "\t" << "Without any Requirements.\n";
        }
 
        detail::stringify_stacktrace(
            std::ostreambuf_iterator{ss},
            call.stacktrace);
 
        return std::move(ss).str();
    }
 
    [[nodiscard]]
    inline StringT stringify_inapplicable_matches(CallReport const& call, std::span<MatchReport> reports)
    {
        MIMICPP_ASSERT(!reports.empty(), "No expectations given.");
 
        StringStreamT ss{};
 
        ss << "Unmatched ";
        detail::stringify_call_report_from(std::ostreambuf_iterator{ss}, call);
        detail::stringify_call_report_target(std::ostreambuf_iterator{ss}, call);
        detail::stringify_call_report_arguments(std::ostreambuf_iterator{ss}, call, "\t");
 
        ss << reports.size() << " inapplicable but otherwise matching Expectation(s):";
 
        for (int i{};
             auto& report : reports)
        {
            auto& [expReport, matchReport] = report;
            ss << "\n\t#" << ++i << " ";
            detail::stringify_expectation_report_from(std::ostreambuf_iterator{ss}, expReport);
 
            ss << "\tBecause ";
            std::visit(
                std::bind_front(detail::inapplicable_reason_printer{}, std::ostreambuf_iterator{ss}),
                expReport.controlReport);
 
            std::ranges::sort(
                matchReport,
                {},
                [](expectation::MatchResult const& m) -> auto const& { return std::get<expectation::MatchSuccess>(m).description; });
            detail::stringify_expectation_report_requirement_adherences(std::ostreambuf_iterator{ss}, matchReport, "\t");
        }
 
        detail::stringify_stacktrace(
            std::ostreambuf_iterator{ss},
            call.stacktrace);
 
        return std::move(ss).str();
    }
 
    [[nodiscard]]
    inline StringT stringify_no_matches(CallReport const& call, std::span<MatchReport> noMatchReports)
    {
        StringStreamT ss{};
 
        ss << "Unmatched ";
        detail::stringify_call_report_from(std::ostreambuf_iterator{ss}, call);
        detail::stringify_call_report_target(std::ostreambuf_iterator{ss}, call);
        detail::stringify_call_report_arguments(std::ostreambuf_iterator{ss}, call, "\t");
 
        std::vector<MatchReport*> applicableReports{};
        for (auto& noMatch : noMatchReports)
        {
            if (std::holds_alternative<state_applicable>(noMatch.expectationReport.controlReport))
            {
                applicableReports.emplace_back(&noMatch);
            }
        }
 
        if (applicableReports.empty())
        {
            ss << "No applicable Expectations available!\n";
        }
        else
        {
            ss << applicableReports.size() << " applicable non-matching Expectation(s):";
 
            for (int i{};
                 auto* report : applicableReports)
            {
                auto& [expReport, matchResults] = *report;
 
                ss << "\n\t#" << ++i << " ";
                detail::stringify_expectation_report_from(std::ostreambuf_iterator{ss}, expReport);
 
                std::ranges::sort(
                    matchResults,
                    {},
                    [](expectation::MatchResult const& m) -> auto const& {
                        return std::visit([](auto const& inner) -> auto const& { return inner.description; }, m);
                    });
                std::ranges::subrange const violations = std::ranges::stable_partition(
                    matchResults,
                    [](expectation::MatchResult const& r) { return std::holds_alternative<expectation::MatchSuccess>(r); });
 
                MIMICPP_ASSERT(!violations.empty(), "Zero violations do not denote a no-match.");
                detail::stringify_expectation_report_requirement_violations(std::ostreambuf_iterator{ss}, violations, "\t");
                detail::stringify_expectation_report_requirement_adherences(
                    std::ostreambuf_iterator{ss},
                    std::span{matchResults.data(), violations.data()},
                    "\t");
            }
        }
 
        detail::stringify_stacktrace(
            std::ostreambuf_iterator{ss},
            call.stacktrace);
 
        return std::move(ss).str();
    }
 
    [[nodiscard]]
    inline StringT stringify_unfulfilled_expectation(ExpectationReport const& expectationReport)
    {
        StringStreamT ss{};
 
        ss << "Unfulfilled ";
        detail::stringify_expectation_report_from(std::ostreambuf_iterator{ss}, expectationReport);
        detail::stringify_expectation_report_target(std::ostreambuf_iterator{ss}, expectationReport);
        ss << "\tBecause ";
        std::visit(
            std::bind_front(detail::unfulfilled_reason_printer{}, std::ostreambuf_iterator{ss}),
            expectationReport.controlReport);
 
        return std::move(ss).str();
    }
 
    [[nodiscard]]
    inline StringT stringify_unhandled_exception(
        CallReport const& call,
        ExpectationReport const& expectationReport,
        std::exception_ptr const& exception)
    {
        StringStreamT ss{};
        ss << "Unhandled Exception ";
 
        try
        {
            std::rethrow_exception(exception);
        }
        catch (const std::exception& e)
        {
            ss << "with message `" << e.what() << "`\n";
        }
        catch (...)
        {
            ss << "of unknown type.\n";
        }
 
        ss << "\t" << "While checking ";
        detail::stringify_expectation_report_from(std::ostreambuf_iterator{ss}, expectationReport);
 
        ss << "For ";
        detail::stringify_call_report_from(std::ostreambuf_iterator{ss}, call);
        detail::stringify_call_report_target(std::ostreambuf_iterator{ss}, call);
        detail::stringify_call_report_arguments(std::ostreambuf_iterator{ss}, call, "\t");
 
        detail::stringify_stacktrace(
            std::ostreambuf_iterator{ss},
            call.stacktrace);
 
        return std::move(ss).str();
    }
}
 
#endif