Expectation.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_EXPECTATION_HPP
#define MIMICPP_EXPECTATION_HPP
 
#pragma once
 
#include "mimic++/Call.hpp"
#include "mimic++/Fwd.hpp"
#include "mimic++/Sequence.hpp"
#include "mimic++/TypeTraits.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/config/Settings.hpp"
#include "mimic++/reporting/CallReport.hpp"
#include "mimic++/reporting/ExpectationReport.hpp"
#include "mimic++/reporting/GlobalReporter.hpp"
#include "mimic++/reporting/TargetReport.hpp"
#include "mimic++/utilities/Concepts.hpp"
#include "mimic++/utilities/SourceLocation.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <algorithm>
    #include <concepts>
    #include <functional>
    #include <memory>
    #include <mutex>
    #include <optional>
    #include <ranges>
    #include <tuple>
    #include <utility>
    #include <vector>
#endif
 
namespace mimicpp::detail
{
    template <typename Return, typename... Params, typename Signature>
    [[nodiscard]]
    std::optional<reporting::RequirementOutcomes> determine_requirement_outcomes(
        reporting::TargetReport const& target,
        call::Info<Return, Params...> const& call,
        Expectation<Signature> const& expectation) noexcept
    {
        try
        {
            return expectation.matches(call);
        }
        catch (...)
        {
            reporting::detail::report_unhandled_exception(
                reporting::make_call_report(
                    target,
                    call,
                    util::stacktrace::current(3u + call.baseStacktraceSkip)),
                expectation.report(),
                std::current_exception());
        }
 
        return std::nullopt;
    }
 
    [[nodiscard]]
    std::vector<reporting::ExpectationReport> gather_expectation_reports(auto&& expectationPtrs)
    {
        auto view = std::views::transform(expectationPtrs, [](auto const& exp) { return exp->report(); });
        return std::vector<reporting::ExpectationReport>{
            view.begin(),
            view.end()};
    }
 
    template <typename Signature>
    [[nodiscard]]
    std::vector<reporting::NoMatchReport> make_no_match_reports(
        std::vector<std::tuple<Expectation<Signature>*, reporting::RequirementOutcomes>>&& outcomes)
    {
        std::vector<reporting::NoMatchReport> reports{};
        reports.reserve(outcomes.size());
        for (auto const& [expectationPtr, outcome] : outcomes)
        {
            reports.emplace_back(
                expectationPtr->report(),
                std::move(outcome));
        }
 
        return reports;
    }
 
    [[nodiscard]]
    constexpr auto find_best_match(std::span<reporting::ExpectationReport const> const matches)
    {
        constexpr auto ratings = [](auto const& el) noexcept -> const auto& {
            return std::get<reporting::state_applicable>(el.controlReport)
                .sequenceRatings;
        };
 
        auto best = std::ranges::begin(matches);
        for (auto iter = best + 1;
             iter != std::ranges::end(matches);
             ++iter)
        {
            if (!sequence::detail::has_better_rating(
                    ratings(*best),
                    ratings(*iter)))
            {
                best = iter;
            }
        }
 
        return std::ranges::distance(std::ranges::begin(matches), best);
    }
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{

    template <typename Signature>
        requires std::same_as<Signature, signature_decay_t<Signature>>
    class Expectation
    {
    public:
        using CallInfoT = call::info_for_signature_t<Signature>;

        using ReturnT = signature_return_type_t<Signature>;

        virtual ~Expectation() = default;

        [[nodiscard]]
        Expectation() = default;

        Expectation(const Expectation&) = delete;

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

        Expectation(Expectation&&) = delete;

        Expectation& operator=(Expectation&&) = delete;

        [[nodiscard]]
        virtual reporting::ExpectationReport report() const = 0;

        [[nodiscard]]
        virtual bool is_satisfied() const noexcept = 0;

        [[nodiscard]]
        virtual bool is_applicable() const noexcept = 0;

        [[nodiscard]]
        virtual reporting::RequirementOutcomes matches(const CallInfoT& call) const = 0;

        virtual void consume(const CallInfoT& call) = 0;

        [[nodiscard]]
        virtual constexpr ReturnT finalize_call(const CallInfoT& call) = 0;

        [[nodiscard]]
        virtual constexpr util::SourceLocation const& from() const noexcept = 0;

        [[nodiscard]]
        virtual constexpr StringT const& mock_name() const noexcept = 0;
    };

    template <typename Signature>
        requires std::same_as<Signature, signature_decay_t<Signature>>
    class ExpectationCollection
    {
    public:
        using CallInfoT = call::info_for_signature_t<Signature>;

        using ExpectationT = Expectation<Signature>;

        using ReturnT = signature_return_type_t<Signature>;

        ~ExpectationCollection() = default;

        [[nodiscard]]
        ExpectationCollection() = default;

        ExpectationCollection(const ExpectationCollection&) = delete;

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

        [[nodiscard]]
        ExpectationCollection(ExpectationCollection&&) = default;

        ExpectationCollection& operator=(ExpectationCollection&&) = default;

        void push(std::shared_ptr<ExpectationT> expectation)
        {
            const std::scoped_lock lock{m_ExpectationsMx};
 
            MIMICPP_ASSERT(std::ranges::find(m_Expectations, expectation) == std::ranges::end(m_Expectations), "Expectation already belongs to this storage.");
 
            m_Expectations.emplace_back(std::move(expectation));
        }

        void remove(std::shared_ptr<ExpectationT> expectation)
        {
            const std::scoped_lock lock{m_ExpectationsMx};
 
            auto iter = std::ranges::find(m_Expectations, expectation);
            MIMICPP_ASSERT(iter != std::ranges::end(m_Expectations), "Expectation does not belong to this storage.");
            m_Expectations.erase(iter);
 
            if (!expectation->is_satisfied())
            {
                reporting::detail::report_unfulfilled_expectation(
                    expectation->report());
            }
        }

        [[nodiscard]]
        ReturnT handle_call(reporting::TargetReport target, CallInfoT call)
        {
            std::vector<ExpectationT*> matches{};
            std::vector<ExpectationT*> inapplicableMatches{};
            std::vector<std::tuple<ExpectationT*, reporting::RequirementOutcomes>> noMatches{};
 
            std::scoped_lock const lock{m_ExpectationsMx};
            evaluate_expectations(target, call, matches, inapplicableMatches, noMatches);
 
            std::size_t const stacktraceSkip{1u + call.baseStacktraceSkip};
            if (!std::ranges::empty(matches))
            {
                std::vector reports = detail::gather_expectation_reports(matches);
                MIMICPP_ASSERT(matches.size() == reports.size(), "Size mismatch.");
                auto const bestIndex = detail::find_best_match(reports);
                MIMICPP_ASSERT(0 <= bestIndex && bestIndex < std::ssize(reports), "Invalid index.");
 
                auto& expectation = *matches[bestIndex];
 
                if (settings::report_success())
                {
                    auto& report = reports[bestIndex];
 
                    // 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 wrong.
                    reporting::detail::report_full_match(
                        reporting::make_call_report(std::move(target), call, util::stacktrace::current(stacktraceSkip)),
                        std::move(report));
                }
 
                expectation.consume(call);
                return expectation.finalize_call(call);
            }
 
            if (!std::ranges::empty(inapplicableMatches))
            {
                reporting::detail::report_inapplicable_matches(
                    reporting::make_call_report(std::move(target), std::move(call), util::stacktrace::current(stacktraceSkip)),
                    detail::gather_expectation_reports(inapplicableMatches));
            }
 
            reporting::detail::report_no_matches(
                reporting::make_call_report(std::move(target), std::move(call), util::stacktrace::current(stacktraceSkip)),
                detail::make_no_match_reports(std::move(noMatches)));
        }
 
    private:
        std::vector<std::shared_ptr<ExpectationT>> m_Expectations{};
        std::mutex m_ExpectationsMx{};
 
        void evaluate_expectations(
            reporting::TargetReport const& target,
            CallInfoT const& call,
            std::vector<ExpectationT*>& matches,
            std::vector<ExpectationT*>& inapplicableMatches,
            std::vector<std::tuple<ExpectationT*, reporting::RequirementOutcomes>>& noMatches)
        {
            for (auto const& exp : std::views::reverse(m_Expectations))
            {
                if (std::optional outcomes = detail::determine_requirement_outcomes(target, call, *exp))
                {
                    if (std::ranges::any_of(outcomes->outcomes, [](auto const& el) { return el == false; }))
                    {
                        noMatches.emplace_back(exp.get(), *std::move(outcomes));
                    }
                    else if (!exp->is_applicable())
                    {
                        inapplicableMatches.emplace_back(exp.get());
                    }
                    else
                    {
                        matches.emplace_back(exp.get());
                    }
                }
            }
        }
    };

    template <typename T, typename Signature>
    concept expectation_policy_for = std::is_move_constructible_v<T>
                                  && std::is_destructible_v<T>
                                  && std::same_as<T, std::remove_cvref_t<T>>
                                  && requires(T& policy, const call::info_for_signature_t<Signature>& info) {
                                         { std::as_const(policy).is_satisfied() } noexcept -> util::boolean_testable;
                                         { std::as_const(policy).matches(info) } -> util::boolean_testable;
                                         { std::as_const(policy).describe() } -> util::explicitly_convertible_to<std::optional<StringT>>;
                                         { policy.consume(info) };
                                     };

    template <typename T, typename Signature>
    concept finalize_policy_for = std::is_move_constructible_v<T>
                               && std::is_destructible_v<T>
                               && std::same_as<T, std::remove_cvref_t<T>>
                               && requires(T& policy, const call::info_for_signature_t<Signature>& info) {
                                      { policy.finalize_call(info) } -> std::convertible_to<signature_return_type_t<Signature>>;
                                  };

    template <typename T>
    concept control_policy = std::is_move_constructible_v<T>
                          && std::is_destructible_v<T>
                          && std::same_as<T, std::remove_cvref_t<T>>
                          && requires(T& policy) {
                                 { std::as_const(policy).is_satisfied() } noexcept -> util::boolean_testable;
                                 { std::as_const(policy).state() } -> std::convertible_to<reporting::control_state_t>;
                                 policy.consume();
                             };

    template <
        typename Signature,
        control_policy ControlPolicy,
        finalize_policy_for<Signature> FinalizePolicy,
        expectation_policy_for<Signature>... Policies>
    class BasicExpectation final
        : public Expectation<Signature>
    {
    public:
        using ControlPolicyT = ControlPolicy;
        using FinalizerT = FinalizePolicy;
        using PolicyListT = std::tuple<Policies...>;
        using CallInfoT = call::info_for_signature_t<Signature>;
        using ReturnT = typename Expectation<Signature>::ReturnT;

        template <typename ControlPolicyArg, typename FinalizerArg, typename... PolicyArgs>
            requires std::constructible_from<ControlPolicyT, ControlPolicyArg>
                      && std::constructible_from<FinalizerT, FinalizerArg>
                      && std::constructible_from<PolicyListT, PolicyArgs...>
        constexpr explicit BasicExpectation(
            util::SourceLocation from,
            reporting::TargetReport target,
            ControlPolicyArg&& controlArg,
            FinalizerArg&& finalizerArg,
            PolicyArgs&&... args)
            noexcept(
                std::is_nothrow_constructible_v<ControlPolicyT, ControlPolicyArg>
                && std::is_nothrow_constructible_v<FinalizerT, FinalizerArg>
                && (std::is_nothrow_constructible_v<Policies, PolicyArgs> && ...))
            : m_From{std::move(from)},
              m_Target{std::move(target)},
              m_ControlPolicy{std::forward<ControlPolicyArg>(controlArg)},
              m_Policies{std::forward<PolicyArgs>(args)...},
              m_Finalizer{std::forward<FinalizerArg>(finalizerArg)}
        {
        }

        [[nodiscard]]
        reporting::ExpectationReport report() const override
        {
            return reporting::ExpectationReport{
                .from = m_From,
                .target = m_Target,
                .controlReport = m_ControlPolicy.state(),
                .finalizerDescription = std::nullopt,
                .requirementDescriptions = std::apply(
                    [&](auto const&... policies) {
                        return std::vector<std::optional<StringT>>{
                            std::optional<StringT>{policies.describe()}...};
                    },
                    m_Policies)};
        }

        [[nodiscard]]
        constexpr bool is_satisfied() const noexcept override
        {
            return m_ControlPolicy.is_satisfied()
                && std::apply(
                       [](const auto&... policies) noexcept {
                           return (... && policies.is_satisfied());
                       },
                       m_Policies);
        }

        [[nodiscard]]
        constexpr bool is_applicable() const noexcept override
        {
            return std::holds_alternative<reporting::state_applicable>(
                m_ControlPolicy.state());
        }

        [[nodiscard]]
        reporting::RequirementOutcomes matches(const CallInfoT& call) const override
        {
            return reporting::RequirementOutcomes{
                .outcomes = gather_requirement_outcomes(call)};
        }

        constexpr void consume(const CallInfoT& call) override
        {
            m_ControlPolicy.consume();
            std::apply(
                [&](auto&... policies) noexcept {
                    (..., policies.consume(call));
                },
                m_Policies);
        }

        [[nodiscard]]
        constexpr ReturnT finalize_call(const CallInfoT& call) override
        {
            return m_Finalizer.finalize_call(call);
        }

        [[nodiscard]]
        constexpr util::SourceLocation const& from() const noexcept override
        {
            return m_From;
        }

        [[nodiscard]]
        constexpr StringT const& mock_name() const noexcept override
        {
            return m_Target.name;
        }
 
    private:
        util::SourceLocation m_From;
        reporting::TargetReport m_Target;
        ControlPolicyT m_ControlPolicy;
        PolicyListT m_Policies;
        [[no_unique_address]] FinalizerT m_Finalizer{};
 
        [[nodiscard]]
        std::vector<bool> gather_requirement_outcomes(CallInfoT const& call) const
        {
            return std::apply(
                [&](auto const&... policies) {
                    return std::vector<bool>{policies.matches(call)...};
                },
                m_Policies);
        }
    };

    class ScopedExpectation
    {
    private:
        class Concept
        {
        public:
            virtual ~Concept() noexcept(false)
            {
            }
 
            Concept(const Concept&) = delete;
            Concept& operator=(const Concept&) = delete;
            Concept(Concept&&) = delete;
            Concept& operator=(Concept&&) = delete;
 
            [[nodiscard]]
            virtual bool is_satisfied() const = 0;
            [[nodiscard]]
            virtual bool is_applicable() const = 0;
 
            [[nodiscard]]
            virtual util::SourceLocation const& from() const noexcept = 0;
            [[nodiscard]]
            virtual StringT const& mock_name() const noexcept = 0;
 
        protected:
            Concept() = default;
        };
 
        template <typename Signature>
        class Model final
            : public Concept
        {
        public:
            using StorageT = ExpectationCollection<Signature>;
            using ExpectationT = Expectation<Signature>;
 
            ~Model() noexcept(false) override
            {
                m_Storage->remove(m_Expectation);
            }
 
            [[nodiscard]]
            explicit Model(
                std::shared_ptr<StorageT>&& storage,
                std::shared_ptr<ExpectationT>&& expectation) noexcept
                : m_Storage{std::move(storage)},
                  m_Expectation{std::move(expectation)}
            {
                MIMICPP_ASSERT(m_Storage, "Storage is nullptr.");
                MIMICPP_ASSERT(m_Expectation, "Expectation is nullptr.");
 
                m_Storage->push(m_Expectation);
            }
 
            [[nodiscard]]
            bool is_satisfied() const override
            {
                return m_Expectation->is_satisfied();
            }
 
            [[nodiscard]]
            bool is_applicable() const override
            {
                return m_Expectation->is_applicable();
            }
 
            [[nodiscard]]
            util::SourceLocation const& from() const noexcept override
            {
                return m_Expectation->from();
            }
 
            [[nodiscard]]
            StringT const& mock_name() const noexcept override
            {
                return m_Expectation->mock_name();
            }
 
        private:
            std::shared_ptr<StorageT> m_Storage;
            std::shared_ptr<ExpectationT> m_Expectation;
        };
 
    public:
        ~ScopedExpectation() noexcept(false)
        {
            // we must call the dtor manually here, because std::unique_ptr's dtor mustn't throw.
            delete m_Inner.release(); // NOLINT(*-uniqueptr-delete-release)
        }

        template <typename Signature>
        [[nodiscard]]
        explicit ScopedExpectation(
            std::shared_ptr<ExpectationCollection<Signature>> collection,
            std::shared_ptr<typename ExpectationCollection<Signature>::ExpectationT> expectation) noexcept
            : m_Inner{
                  std::make_unique<Model<Signature>>(
                      std::move(collection),
                      std::move(expectation))}
        {
        }

        template <typename T>
            requires requires(util::SourceLocation loc) {
                { std::declval<T&&>().finalize(loc) } -> std::convertible_to<ScopedExpectation>;
            }
        [[nodiscard]]
        explicit(false) constexpr ScopedExpectation(T&& object, util::SourceLocation loc = {})
            : ScopedExpectation{std::forward<T>(object).finalize(std::move(loc))}
        {
        }

        ScopedExpectation(ScopedExpectation const&) = delete;

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

        [[nodiscard]]
        ScopedExpectation(ScopedExpectation&&) = default;

        ScopedExpectation& operator=(ScopedExpectation&&) = default;

        [[nodiscard]]
        bool is_satisfied() const
        {
            return m_Inner->is_satisfied();
        }

        [[nodiscard]]
        bool is_applicable() const
        {
            return m_Inner->is_applicable();
        }

        [[nodiscard]]
        util::SourceLocation const& from() const noexcept
        {
            return m_Inner->from();
        }

        [[nodiscard]]
        StringT const& mock_name() const noexcept
        {
            return m_Inner->mock_name();
        }
 
    private:
        std::unique_ptr<Concept> m_Inner;
    };

}
 
#endif