Registry.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_EXPECTATION_REGISTRY_HPP
#define MIMICPP_EXPECTATION_REGISTRY_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/Sequence.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/expectation/Expectation.hpp"
#include "mimic++/reporting/GlobalReporter.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <algorithm>
    #include <mutex>
    #include <optional>
    #include <ranges>
    #include <span>
    #include <tuple>
    #include <utility>
    #include <vector>
#endif
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::expectation
{
    class Registry
    {
    public:
        using Ptr = std::shared_ptr<Registry>;

        Registry(Registry const&) = delete;

        Registry& operator=(Registry const&) = delete;

        [[nodiscard]]
        Registry(Registry&&) = delete;

        Registry& operator=(Registry&&) = delete;

        ~Registry() = default;

        [[nodiscard]]
        Registry() = default;

        template <typename... Args>
            requires std::constructible_from<Expectation, Args...>
        [[nodiscard]]
        Expectation create(Args&&... args)
        {
            std::scoped_lock const lock{m_ExpectationsMx};
            return m_Expectations.emplace_back(std::forward<Args>(args)...);
        }

        void remove(Expectation const& expectation)
        {
            std::scoped_lock const lock{m_ExpectationsMx};
 
            auto const iter = std::ranges::find(m_Expectations, expectation);
            MIMICPP_ASSERT(iter != m_Expectations.cend(), "Expectation does not belong to this registry.");
            m_Expectations.erase(iter);
 
            if (!expectation.is_satisfied())
            {
                reporting::detail::report_unfulfilled_expectation(expectation.report());
            }
        }

        template <typename Signature>
        [[nodiscard]]
        signature_return_type_t<Signature> handle_call(reporting::TargetReport target, call::info_for_signature_t<Signature> call)
        {
            std::scoped_lock const lock{m_ExpectationsMx};
            auto&& [matches, inapplicableMatches, noMatches] = evaluate_expectations(target, call);
 
            std::size_t const stacktraceSkip{1u + call.baseStacktraceSkip};
            if (!std::ranges::empty(matches))
            {
                return handle_matched_call<Signature>(
                    std::move(target),
                    std::move(call),
                    std::move(matches),
                    stacktraceSkip + 1u);
            }
 
            if (!std::ranges::empty(inapplicableMatches))
            {
                reporting::detail::report_inapplicable_matches(
                    reporting::make_call_report(std::move(target), std::move(call), util::stacktrace::current(stacktraceSkip)),
                    make_match_reports(std::move(inapplicableMatches)));
            }
 
            reporting::detail::report_no_matches(
                reporting::make_call_report(std::move(target), std::move(call), util::stacktrace::current(stacktraceSkip)),
                make_match_reports(std::move(noMatches)));
        }
 
    private:
        std::vector<Expectation> m_Expectations{};
        std::mutex m_ExpectationsMx{};
 
        [[nodiscard]]
        static std::optional<MatchResults> try_match_call(
            reporting::TargetReport const& target,
            auto const& callInfo,
            Expectation const& expectation) noexcept
        {
            try
            {
                return expectation.matches(callInfo);
            }
            catch (...)
            {
                reporting::detail::report_unhandled_exception(
                    reporting::make_call_report(
                        target,
                        callInfo,
                        util::stacktrace::current(3u + callInfo.baseStacktraceSkip)),
                    expectation.report(),
                    std::current_exception());
            }
 
            return std::nullopt;
        }
 
        struct evaluation_results
        {
            struct entry
            {
                std::reference_wrapper<Expectation> expectation;
                MatchResults results;
 
                [[nodiscard]]
                reporting::MatchReport to_match_report() &&
                {
                    return reporting::MatchReport{
                        .expectationReport = expectation.get().report(),
                        .matchResults = std::move(results),
                    };
                }
            };
 
            std::vector<entry> matches{};
            std::vector<entry> inapplicableMatches{};
            std::vector<entry> noMatches{};
        };
 
        [[nodiscard]]
        auto evaluate_expectations(reporting::TargetReport const& target, auto const& callInfo)
        {
            evaluation_results results{};
 
            for (auto& exp : std::views::reverse(m_Expectations))
            {
                if (std::optional result = try_match_call(target, callInfo, exp))
                {
                    if (std::ranges::any_of(*result, [](auto const& el) { return std::holds_alternative<MatchFailure>(el); }))
                    {
                        results.noMatches.emplace_back(exp, *std::move(result));
                    }
                    else if (!exp.is_applicable())
                    {
                        results.inapplicableMatches.emplace_back(exp, *std::move(result));
                    }
                    else
                    {
                        results.matches.emplace_back(exp, *std::move(result));
                    }
                }
            }
 
            return results;
        }
 
        template <typename Signature>
        [[nodiscard]]
        signature_return_type_t<Signature> handle_matched_call(
            reporting::TargetReport&& target,
            call::info_for_signature_t<Signature>&& callInfo,
            std::vector<evaluation_results::entry>&& matches,
            std::size_t const stacktraceSkip)
        {
            std::vector reports = std::invoke([&] {
                auto view = std::views::transform(
                    matches,
                    [](auto const& entry) { return entry.expectation.get().report(); });
                return std::vector(view.begin(), view.end());
            });
            MIMICPP_ASSERT(matches.size() == reports.size(), "Size mismatch.");
            auto const bestIter = std::ranges::max_element(
                reports,
                std::not_fn(&sequence::detail::has_better_rating),
                [](reporting::ExpectationReport const& el) noexcept -> const auto& {
                    return std::get<reporting::state_applicable>(el.controlReport).sequenceRatings;
                });
            auto& bestMatch = matches[std::ranges::distance(reports.cbegin(), bestIter)];
 
            if (settings::report_success())
            {
                // Todo: Avoid the call copy
                // Maybe we can prevent the copy here, but we should keep the instruction order as-is,
                // because in cases of a throwing finalizer, we might introduce bugs.
                // At least there are some tests, which will fail if done incorrectly.
                reporting::detail::report_full_match(
                    reporting::make_call_report(std::move(target), callInfo, util::stacktrace::current(stacktraceSkip)),
                    {.expectationReport = std::move(*bestIter), .matchResults = std::move(bestMatch.results)});
            }
 
            return bestMatch.expectation.get().consume(callInfo);
        }
 
        [[nodiscard]]
        static std::vector<reporting::MatchReport> make_match_reports(std::vector<evaluation_results::entry>&& outcomes)
        {
            std::vector<reporting::MatchReport> reports{};
            reports.reserve(outcomes.size());
            std::ranges::transform(
                outcomes,
                std::back_inserter(reports),
                [](evaluation_results::entry& el) { return std::move(el).to_match_report(); });
 
            return reports;
        }
    };
}
 
#endif