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++/Call.hpp"
#include "mimic++/Expectation.hpp"
#include "mimic++/ExpectationBuilder.hpp"
#include "mimic++/Fwd.hpp"
#include "mimic++/TypeTraits.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/policies/GeneralPolicies.hpp"
#include "mimic++/printing/TypePrinter.hpp"
#include "mimic++/reporting/TargetReport.hpp"
#include "mimic++/utilities/Stacktrace.hpp"
#include "mimic++/utilities/TypeList.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <cstddef>
    #include <functional>
    #include <optional>
    #include <tuple>
    #include <type_traits>
    #include <utility>
#endif
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{
    class MockSettings
    {
    public:
        std::optional<StringT> name{};
        std::size_t stacktraceSkip{};
    };
}
 
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,
        util::type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            util::SourceLocation from = {}) noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<Derived const&>(*this)
                .handle_call(
                    reporting::TypeReport::make<Signature>(),
                    std::tuple{std::ref(params)...},
                    std::move(from));
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::any,
        util::type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            util::SourceLocation from = {}) const noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<Derived const&>(*this)
                .handle_call(
                    reporting::TypeReport::make<Signature>(),
                    std::tuple{std::ref(params)...},
                    std::move(from));
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::non_const,
        ValueCategory::lvalue,
        util::type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            util::SourceLocation from = {}) & noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<Derived const&>(*this)
                .handle_call(
                    reporting::TypeReport::make<Signature>(),
                    std::tuple{std::ref(params)...},
                    std::move(from));
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::lvalue,
        util::type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            util::SourceLocation from = {}) const& noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<Derived const&>(*this)
                .handle_call(
                    reporting::TypeReport::make<Signature>(),
                    std::tuple{std::ref(params)...},
                    std::move(from));
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::non_const,
        ValueCategory::rvalue,
        util::type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            util::SourceLocation from = {}) && noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<Derived const&>(*this)
                .handle_call(
                    reporting::TypeReport::make<Signature>(),
                    std::tuple{std::ref(params)...},
                    std::move(from));
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class DefaultCallInterface<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::rvalue,
        util::type_list<Params...>>
    {
    public:
        constexpr signature_return_type_t<Signature> operator()(
            Params... params,
            util::SourceLocation from = {}) const&& noexcept(signature_is_noexcept_v<Signature>)
        {
            return static_cast<Derived const&>(*this)
                .handle_call(
                    reporting::TypeReport::make<Signature>(),
                    std::tuple{std::ref(params)...},
                    std::move(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,
        util::type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args)
        {
            return static_cast<Derived const&>(*this)
                .make_expectation_builder(reporting::TypeReport::make<Signature>(), std::forward<Args>(args)...);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::any,
        util::type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args) const
        {
            return static_cast<Derived const&>(*this)
                .make_expectation_builder(reporting::TypeReport::make<Signature>(), std::forward<Args>(args)...);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::non_const,
        ValueCategory::lvalue,
        util::type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args) &
        {
            return static_cast<Derived const&>(*this)
                .make_expectation_builder(reporting::TypeReport::make<Signature>(), std::forward<Args>(args)...);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::lvalue,
        util::type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args) const&
        {
            return static_cast<Derived const&>(*this)
                .make_expectation_builder(reporting::TypeReport::make<Signature>(), std::forward<Args>(args)...);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::non_const,
        ValueCategory::rvalue,
        util::type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args) &&
        {
            return static_cast<Derived const&>(*this)
                .make_expectation_builder(reporting::TypeReport::make<Signature>(), std::forward<Args>(args)...);
        }
    };
 
    template <typename Derived, typename Signature, typename... Params>
    class MockFrontend<
        Derived,
        Signature,
        Constness::as_const,
        ValueCategory::rvalue,
        util::type_list<Params...>>
    {
    public:
        template <typename... Args>
            requires(... && requirement_for<Args, Params>)
        [[nodiscard]]
        constexpr auto expect_call(Args&&... args) const&&
        {
            return static_cast<Derived const&>(*this)
                .make_expectation_builder(reporting::TypeReport::make<Signature>(), 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, util::type_list<Params...>>
        : public MockFrontend<
              // MockFrontend doesn't need to know about the call-convention, thus remove it
              BasicMock<Signature, util::type_list<Params...>>,
              signature_remove_call_convention_t<Signature>>,
          public call_interface_t<
              BasicMock<Signature, util::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,
            MockSettings settings) noexcept
            : m_Expectations{std::move(collection)},
              m_Settings{std::move(settings)}
        {
            MIMICPP_ASSERT(m_Settings.name, "Empty mock-name.");
 
            m_Settings.stacktraceSkip += 2u; // skips the operator() and the handle_call from the stacktrace
        }
 
    private:
        ExpectationCollectionPtrT m_Expectations;
        MockSettings m_Settings;
 
        [[nodiscard]]
        constexpr signature_return_type_t<SignatureT> handle_call(
            reporting::TypeReport overloadReport,
            std::tuple<std::reference_wrapper<std::remove_reference_t<Params>>...>&& params,
            util::SourceLocation from) const
        {
            return m_Expectations->handle_call(
                reporting::TargetReport{
                    .name{*m_Settings.name},
                    .overloadReport{std::move(overloadReport)}},
                call::info_for_signature_t<SignatureT>{
                    .args{std::move(params)},
                    .fromCategory{refQualification},
                    .fromConstness{constQualification},
                    .fromSourceLocation{std::move(from)},
                    .baseStacktraceSkip{m_Settings.stacktraceSkip}});
        }
 
        template <typename... Args>
        [[nodiscard]]
        constexpr auto make_expectation_builder(reporting::TypeReport overloadReport, Args&&... args) const
        {
            return detail::make_expectation_builder(
                       m_Expectations,
                       reporting::TargetReport{.name = *m_Settings.name, .overloadReport = std::move(overloadReport)},
                       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<util::type_list<UniqueSignatures...>>
    {
        [[nodiscard]]
        static auto make()
        {
            return std::tuple{
                std::make_shared<ExpectationCollection<UniqueSignatures>>()...};
        }
    };
 
    template <typename... Signatures>
    [[nodiscard]]
    StringT generate_mock_name()
    {
        StringStreamT out{};
        out << "Mock<";
        printing::type::detail::print_separated(
            std::ostreambuf_iterator{out},
            ", ",
            util::type_list<Signatures...>{});
        out << ">";
 
        return std::move(out).str();
    }
}
 
MIMICPP_DETAIL_MODULE_EXPORT 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{MockSettings{}}
        {
        }

        [[nodiscard]]
        explicit Mock(MockSettings settings)
            : Mock{
                  detail::expectation_collection_factory<
                      util::detail::unique_list_t<
                          signature_decay_t<FirstSignature>,
                          signature_decay_t<OtherSignatures>...>>::make(),
                  complete_settings(std::move(settings))}
        {
        }

        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, MockSettings const& settings) noexcept
            // clang-format off
            : detail::BasicMock<FirstSignature>{
                util::detail::get<detail::expectation_collection_ptr_for<FirstSignature>>(collections),
                settings},
            detail::BasicMock<OtherSignatures>{
                util::detail::get<detail::expectation_collection_ptr_for<OtherSignatures>>(collections),
                settings}...
        // clang-format on
        {
        }
 
        [[nodiscard]]
        static MockSettings complete_settings(MockSettings settings)
        {
            if (!settings.name)
            {
                settings.name = detail::generate_mock_name<FirstSignature, OtherSignatures...>();
            }
 
            return settings;
        }
    };

}
 
#endif