Expectation.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_EXPECTATION_HPP
#define MIMICPP_EXPECTATION_EXPECTATION_HPP
 
#pragma once
 
#include "mimic++/Call.hpp"
#include "mimic++/Fwd.hpp"
#include "mimic++/TypeTraits.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/expectation/Common.hpp"
#include "mimic++/reporting/ExpectationReport.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <any>
    #include <memory>
    #include <optional>
    #include <tuple>
    #include <type_traits>
    #include <utility>
    #include <vector>
#endif
 
namespace mimicpp::expectation
{

    class Expectation
    {
    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 util::SourceLocation const& from() const noexcept = 0;
 
            [[nodiscard]]
            virtual StringT const& mock_name() const noexcept = 0;
 
            [[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 std::optional<MatchResults> matches(std::any&& opaqueCallInfo) const = 0;
 
            [[nodiscard]]
            virtual std::any consume(std::any&& opaqueCallInfo) = 0;
 
        protected:
            Concept() = default;
        };
 
        template <
            typename Signature,
            control_policy ControlPolicy,
            finalize_policy_for<Signature> FinalizePolicy,
            expectation_policy_for<Signature>... Policies>
        class Model final
            : public Concept
        {
        public:
            using CallInfoRef = std::reference_wrapper<call::info_for_signature_t<Signature> const>;
            using Return = signature_return_type_t<Signature>;
            using PolicyList = std::tuple<Policies...>;
 
            template <typename ControlPolicyArg, typename FinalizerArg, typename... PolicyArgs>
            [[nodiscard]]
            explicit constexpr Model(
                util::SourceLocation from,
                reporting::TargetReport target,
                ControlPolicyArg&& controlArg,
                FinalizerArg&& finalizerArg,
                PolicyArgs&&... args)
                : 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]]
            util::SourceLocation const& from() const noexcept override
            {
                return m_From;
            }
 
            [[nodiscard]]
            StringT const& mock_name() const noexcept override
            {
                return m_Target.name;
            }
 
            [[nodiscard]]
            reporting::ExpectationReport report() const override
            {
                return reporting::ExpectationReport{
                    .from = m_From,
                    .target = m_Target,
                    .controlReport = m_ControlPolicy.state(),
                    .finalizerDescription = std::nullopt,
                };
            }
 
            [[nodiscard]]
            bool is_satisfied() const noexcept override
            {
                return m_ControlPolicy.is_satisfied()
                    && std::apply(
                           [](auto const&... policies) { return (... && policies.is_satisfied()); },
                           m_Policies);
            }
 
            [[nodiscard]]
            bool is_applicable() const noexcept override
            {
                return std::holds_alternative<reporting::state_applicable>(m_ControlPolicy.state());
            }
 
            [[nodiscard]]
            std::optional<MatchResults> matches(std::any&& opaqueCallInfo) const override
            {
                MIMICPP_ASSERT(opaqueCallInfo.has_value(), "Empty call is not allowed.");
                if (auto const* const info = std::any_cast<CallInfoRef>(&opaqueCallInfo))
                {
                    return {gather_requirement_outcomes(info->get())};
                }
 
                return std::nullopt;
            }
 
            [[nodiscard]]
            std::any consume(std::any&& opaqueCallInfo) override
            {
                auto const* const info = std::any_cast<CallInfoRef>(&opaqueCallInfo);
                MIMICPP_ASSERT(info, "Invalid call type.");
 
                m_ControlPolicy.consume();
                std::apply(
                    [&](auto&... policies) { (..., policies.consume(info->get())); },
                    m_Policies);
 
                return finalize(info->get());
            }
 
        private:
            util::SourceLocation m_From;
            reporting::TargetReport m_Target;
            ControlPolicy m_ControlPolicy;
            PolicyList m_Policies;
            [[no_unique_address]] FinalizePolicy m_Finalizer{};
 
            [[nodiscard]]
            MatchResults gather_requirement_outcomes(call::info_for_signature_t<Signature> const& call) const
            {
                return std::apply(
                    [&](auto const&... policies) { return MatchResults{policies.matches(call)...}; },
                    m_Policies);
            }
 
            [[nodiscard]]
            std::any finalize(call::info_for_signature_t<Signature> const& call)
            {
                // Workaround: MSVC (x86, Release) emits C4702 "unreachable code" here when the finalizer always throws (e.g. finally::throws),
                // because the optimizer inlines it.
                // By constructing the `result` first empty and then re-assigning it, seems to please it.
                std::any result{};
 
                if constexpr (std::is_void_v<Return>)
                {
                    m_Finalizer.finalize_call(call);
                    result = std::make_any<call::ResultStorage<void>>();
                }
                else
                {
                    result = std::make_any<call::ResultStorage<Return>>(m_Finalizer.finalize_call(call));
                }
 
                return result;
            }
        };
 
    public:
        virtual ~Expectation() = default;

        Expectation(Expectation const&) = default;

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

        Expectation(Expectation&&) = default;

        Expectation& operator=(Expectation&&) = default;

        template <
            typename Signature,
            control_policy ControlPolicy,
            finalize_policy_for<Signature> FinalizePolicy,
            expectation_policy_for<Signature>... Policies>
        [[nodiscard]] //
        explicit Expectation(
            std::in_place_type_t<Signature> const /*signatureTag*/,
            util::SourceLocation from,
            reporting::TargetReport target,
            ControlPolicy controlPolicy,
            FinalizePolicy finalizePolicy,
            Policies... policies)
            : m_Inner{
                  std::make_shared<Model<Signature, ControlPolicy, FinalizePolicy, Policies...>>(
                      std::move(from),
                      std::move(target),
                      std::move(controlPolicy),
                      std::move(finalizePolicy),
                      std::move(policies)...)}
        {
        }

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

        [[nodiscard]]
        StringT const& mock_name() const noexcept
        {
            return m_Inner->mock_name();
        }

        [[nodiscard]]
        reporting::ExpectationReport report() const
        {
            return m_Inner->report();
        }

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

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

        template <typename Return, typename... Args>
        [[nodiscard]]
        std::optional<MatchResults> matches(call::Info<Return, Args...> const& callInfo) const
        {
            return m_Inner->matches(std::any{std::ref(callInfo)});
        }

        template <typename Return, typename... Args>
        [[nodiscard]]
        Return consume(call::Info<Return, Args...> const& callInfo)
        {
            std::any opaqueResult = m_Inner->consume(std::any{std::ref(callInfo)});
            auto* const resultStorage = std::any_cast<call::ResultStorage<Return>>(&opaqueResult);
            MIMICPP_ASSERT(resultStorage, "Invalid result-type.");
 
            return resultStorage->extract();
        }
 
        [[nodiscard]]
        friend bool operator==(Expectation const&, Expectation const&) = default;
 
    private:
        std::shared_ptr<Concept> m_Inner;
    };

}
 
#endif