Mock.hpp

Go to the documentation of this file.

// //          Copyright Dominic (DNKpp) Koepke 2024 - 2024.
// // 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++/ExpectationPolicies.hpp"
#include "mimic++/TypeTraits.hpp"
#include "mimic++/Utility.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) noexcept
            : m_Expectations{std::move(collection)}
        {
        }
 
    private:
        ExpectationCollectionPtrT m_Expectations;
 
        [[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});
        }
 
        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{
                  detail::expectation_collection_factory<
                      detail::unique_list_t<
                          signature_decay_t<FirstSignature>,
                          signature_decay_t<OtherSignatures>...>>::make()}
        {
        }
 
        Mock(const Mock&) = delete;
 
        Mock& operator=(const Mock&) = delete;
 
        [[nodiscard]]
        Mock(Mock&&) = default;
 
        Mock& operator=(Mock&&) = default;
 
    private:
        template <typename... Collections>
        explicit Mock(std::tuple<Collections...> collections) noexcept
            : detail::BasicMock<FirstSignature>{std::get<detail::expectation_collection_ptr_for<FirstSignature>>(collections)},
              detail::BasicMock<OtherSignatures>{std::get<detail::expectation_collection_ptr_for<OtherSignatures>>(collections)}...
        {
        }
    };
 
}
 
#endif