Mock.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_MOCK_HPP
#define MIMICPP_MOCK_HPP
 
#pragma once
 
#include "mimic++/Expectation.hpp"
#include "mimic++/ExpectationBuilder.hpp"
#include "mimic++/Fwd.hpp"
#include "mimic++/Stacktrace.hpp"
#include "mimic++/TypeTraits.hpp"
#include "mimic++/Utility.hpp"
#include "mimic++/policies/GeneralPolicies.hpp"
 
namespace mimicpp::detail
{
    template <typename Derived, typename Signature>
    using call_interface_t = typename call_convention_traits<
        signature_call_convention_t<Signature>>::template call_interface_t<Derived, Signature>;
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::non_const,
        ValueCategory::any,
        type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            const std::source_location& from = std::source_location::current()) noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<const Derived&>(*this)
                .handle_call(std::tuple{std::ref(params)...}, from);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::any,
        type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            const std::source_location& from = std::source_location::current()) const noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<const Derived&>(*this)
                .handle_call(std::tuple{std::ref(params)...}, from);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::non_const,
        ValueCategory::lvalue,
        type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            const std::source_location& from = std::source_location::current()) & noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<const Derived&>(*this)
                .handle_call(std::tuple{std::ref(params)...}, from);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::lvalue,
        type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            const std::source_location& from = std::source_location::current()) const& noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<const Derived&>(*this)
                .handle_call(std::tuple{std::ref(params)...}, from);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::non_const,
        ValueCategory::rvalue,
        type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            const std::source_location& from = std::source_location::current()) && noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<const Derived&>(*this)
                .handle_call(std::tuple{std::ref(params)...}, from);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::rvalue,
        type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            const std::source_location& from = std::source_location::current()) const&& noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<const Derived&>(*this)
                .handle_call(std::tuple{std::ref(params)...}, from);
        }
    };
 
    template <
        typename Derived,
        typename Signature,
        Constness constQualifier = signature_const_qualification_v<Signature>,
        ValueCategory refQualifier = signature_ref_qualification_v<Signature>,
        typename ParamList = signature_param_list_t<Signature>>
    class MockFrontend;
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::non_const,
        ValueCategory::any,
        type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args)
        {
            return static_cast<const Derived&>(*this)
                .make_expectation_builder(std::forward<Args>(args)...);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::any,
        type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args) const
        {
            return static_cast<const Derived&>(*this)
                .make_expectation_builder(std::forward<Args>(args)...);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::non_const,
        ValueCategory::lvalue,
        type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args) &
        {
            return static_cast<const Derived&>(*this)
                .make_expectation_builder(std::forward<Args>(args)...);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::lvalue,
        type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args) const&
        {
            return static_cast<const Derived&>(*this)
                .make_expectation_builder(std::forward<Args>(args)...);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::non_const,
        ValueCategory::rvalue,
        type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args) &&
        {
            return static_cast<const Derived&>(*this)
                .make_expectation_builder(std::forward<Args>(args)...);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::rvalue,
        type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args) const&&
        {
            return static_cast<const Derived&>(*this)
                .make_expectation_builder(std::forward<Args>(args)...);
        }
    };
 
    template <typename Signature>
    using expectation_collection_ptr_for = std::shared_ptr<ExpectationCollection<signature_decay_t<Signature>>>;
 
    template <typename Signature, typename ParamList = signature_param_list_t<Signature>>
    class BasicMock;
 
    template <typename Signature, typename... Params>
    class BasicMock<Signature, type_list<Params...>>
        : public MockFrontend<
              // MockFrontend doesn't need to know about the call-convention, thus remove it
              BasicMock<Signature, type_list<Params...>>,
              signature_remove_call_convention_t<Signature>>,
          public call_interface_t<
              BasicMock<Signature, type_list<Params...>>,
              Signature>
    {
        using SignatureT = signature_remove_call_convention_t<Signature>;
 
        friend class MockFrontend<BasicMock, SignatureT>;
        friend call_interface_t<BasicMock, Signature>;
 
        static constexpr Constness constQualification = signature_const_qualification_v<SignatureT>;
        static constexpr ValueCategory refQualification = signature_ref_qualification_v<SignatureT>;
 
    protected:
        using ExpectationCollectionPtrT = expectation_collection_ptr_for<SignatureT>;
 
        [[nodiscard]]
        explicit BasicMock(
            ExpectationCollectionPtrT collection,
            const std::size_t stacktraceSkip) noexcept
            : m_Expectations{std::move(collection)},
              m_StacktraceSkip{stacktraceSkip + 2u} // skips the operator() and the handle_call from the stacktrace
        {
        }
 
    private:
        ExpectationCollectionPtrT m_Expectations;
        std::size_t m_StacktraceSkip;
 
        [[nodiscard]]
        constexpr signature_return_type_t<SignatureT> handle_call(
            std::tuple<std::reference_wrapper<std::remove_reference_t<Params>>...>&& params,
            const std::source_location& from) const
        {
            return m_Expectations->handle_call(
                call::info_for_signature_t<SignatureT>{
                    .args = std::move(params),
                    .fromCategory = refQualification,
                    .fromConstness = constQualification,
                    .fromSourceLocation = from,
                    .stacktrace = stacktrace::current(m_StacktraceSkip)});
        }
 
        template <typename... Args>
        [[nodiscard]]
        constexpr auto make_expectation_builder(Args&&... args) const
        {
            return detail::make_expectation_builder(m_Expectations, std::forward<Args>(args)...)
                && expectation_policies::Category<refQualification>{}
                && expectation_policies::Constness<constQualification>{};
        }
    };
 
    template <typename List>
    struct expectation_collection_factory;
 
    template <typename... UniqueSignatures>
    struct expectation_collection_factory<type_list<UniqueSignatures...>>
    {
        [[nodiscard]]
        static auto make()
        {
            return std::tuple{
                std::make_shared<ExpectationCollection<UniqueSignatures>>()...};
        }
    };
}
 
namespace mimicpp
{

    template <typename FirstSignature, typename... OtherSignatures>
        requires is_overload_set_v<FirstSignature, OtherSignatures...>
    class Mock
        : public detail::BasicMock<FirstSignature>,
          public detail::BasicMock<OtherSignatures>...
    {
    public:
        using detail::BasicMock<FirstSignature>::operator();
        using detail::BasicMock<FirstSignature>::expect_call;
        using detail::BasicMock<OtherSignatures>::operator()...;
        using detail::BasicMock<OtherSignatures>::expect_call...;

        ~Mock() = default;

        [[nodiscard]]
        Mock()
            : Mock{0u}
        {
        }

        [[nodiscard]]
        explicit Mock(const std::size_t baseStacktraceSkip)
            : Mock{
                  detail::expectation_collection_factory<
                      detail::unique_list_t<
                          signature_decay_t<FirstSignature>,
                          signature_decay_t<OtherSignatures>...>>::make(),
                  baseStacktraceSkip}
        {
        }

        Mock(const Mock&) = delete;

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

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

        Mock& operator=(Mock&&) = default;
 
    private:
        template <typename... Collections>
        [[nodiscard]]
        explicit Mock(
            std::tuple<Collections...> collections,
            const std::size_t stacktraceSkip) noexcept
            : detail::BasicMock<FirstSignature>{
                  std::get<detail::expectation_collection_ptr_for<FirstSignature>>(collections),
                  stacktraceSkip},
              // clang-format off
              detail::BasicMock<OtherSignatures>{
                  std::get<detail::expectation_collection_ptr_for<OtherSignatures>>(collections),
                  stacktraceSkip}...
        // clang-format on
        {
        }
    };

}
 
#endif