ArgRequirementPolicies.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_POLICIES_ARG_REQUIREMENT_POLICIES_HPP
#define MIMICPP_POLICIES_ARG_REQUIREMENT_POLICIES_HPP
 
#pragma once
 
#include "mimic++/matchers/Common.hpp"
#include "mimic++/policies/ArgumentList.hpp"
 
#include <concepts>
// ReSharper disable once CppUnusedIncludeDirective
#include <functional> // std::invoke
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace mimicpp::expectation_policies
{
    template <typename Matcher>
    struct matcher_matches_fn
    {
    public:
        const Matcher& matcher;
 
        template <typename... Args>
            requires std::invocable<
                decltype(detail::matches_hook::matches),
                const Matcher&,
                Args&...>
        [[nodiscard]]
        // projected arguments may come as value, so Args& won't work in all cases
        // just forward them as lvalue-ref
        constexpr bool operator()(Args&&... args) const
            noexcept(
                std::is_nothrow_invocable_v<
                    decltype(detail::matches_hook::matches),
                    const Matcher&,
                    Args&...>)
        {
            return detail::matches_hook::matches(matcher, args...);
        }
        constexpr bool operator()(Args&&... args) const {…}
    };
    struct matcher_matches_fn {…};
 
    template <typename Matcher, typename MatchesStrategy, typename DescribeStrategy>
    class ArgsRequirement
    {
    public:
        [[nodiscard]]
        explicit constexpr ArgsRequirement(
            Matcher matcher,
            MatchesStrategy matchesStrategy,
            DescribeStrategy describeStrategy)
            noexcept(
                std::is_nothrow_move_constructible_v<Matcher>
                && std::is_nothrow_move_constructible_v<MatchesStrategy>
                && std::is_nothrow_move_constructible_v<DescribeStrategy>)
            : m_Matcher{std::move(matcher)},
              m_MatchesStrategy{std::move(matchesStrategy)},
              m_DescribeStrategy{std::move(describeStrategy)}
        {
        }
        explicit constexpr ArgsRequirement( {…}
 
        [[nodiscard]]
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
        static constexpr bool is_satisfied() noexcept {…}
 
        template <typename Return, typename... Args>
            requires std::is_invocable_r_v<bool, const MatchesStrategy&, matcher_matches_fn<Matcher>, const call::Info<Return, Args...>&>
        [[nodiscard]]
        constexpr bool matches(const call::Info<Return, Args...>& info) const
            noexcept(std::is_nothrow_invocable_v<const MatchesStrategy&, matcher_matches_fn<Matcher>, const call::Info<Return, Args...>&>)
        {
            return std::invoke(
                m_MatchesStrategy,
                matcher_matches_fn<Matcher>{m_Matcher},
                info);
        }
        constexpr bool matches(const call::Info<Return, Args...>& info) const {…}
 
        template <typename Return, typename... Args>
        static constexpr void consume([[maybe_unused]] const call::Info<Return, Args...>& info) noexcept
        {
        }
        static constexpr void consume([[maybe_unused]] const call::Info<Return, Args...>& info) noexcept {…}
 
        [[nodiscard]]
        StringT describe() const
        {
            return std::invoke(
                m_DescribeStrategy,
                detail::describe_hook::describe(m_Matcher));
        }
        StringT describe() const {…}
 
    private:
        Matcher m_Matcher;
        [[no_unique_address]] MatchesStrategy m_MatchesStrategy;
        [[no_unique_address]] DescribeStrategy m_DescribeStrategy;
    };
    class ArgsRequirement {…};
}
namespace mimicpp::expectation_policies {…}
 
namespace mimicpp::expect
{
    namespace detail
    {
        template <std::size_t index, std::size_t... others>
        struct arg_requirement_describer
        {
            [[nodiscard]]
            StringT operator()(const StringViewT matcherDescription) const
            {
                StringStreamT out{};
                out << "expect: arg[" << index;
                ((out << ", " << others), ...);
                out << "] " << matcherDescription;
                return std::move(out).str();
            }
        };
 
        struct all_args_requirement_describer
        {
            [[nodiscard]]
            StringT operator()(const StringViewT matcherDescription) const
            {
                StringStreamT out{};
                out << "expect: arg[all] " << matcherDescription;
                return std::move(out).str();
            }
        };
 
        template <
            std::size_t... indices,
            typename Matcher,
            typename... Projections>
        [[nodiscard]]
        constexpr auto make_args_policy(
            Matcher&& matcher,
            std::tuple<Projections...>&& projections)
        {
            static_assert(
                sizeof...(indices) == sizeof...(Projections),
                "Indices and projections size mismatch.");
 
            using arg_selector_t = mimicpp::detail::args_selector_fn<
                std::add_lvalue_reference_t,
                std::index_sequence<indices...>>;
            using apply_strategy_t = mimicpp::detail::arg_list_indirect_apply_fn<std::remove_cvref_t<Projections>...>;
            using describe_strategy_t = arg_requirement_describer<indices...>;
 
            return expectation_policies::ArgsRequirement{
                std::forward<Matcher>(matcher),
                mimicpp::detail::apply_args_fn(
                    arg_selector_t{},
                    apply_strategy_t{std::move(projections)}),
                describe_strategy_t{}};
        }
    }


    template <std::size_t index, typename Matcher, typename Projection = std::identity>
    [[nodiscard]]
    constexpr auto arg(
        Matcher&& matcher,
        Projection&& projection = {})
        noexcept(
            std::is_nothrow_constructible_v<std::remove_cvref_t<Matcher>, Matcher>
            && std::is_nothrow_constructible_v<std::remove_cvref_t<Projection>, Projection>)
    {
        return detail::make_args_policy<index>(
            std::forward<Matcher>(matcher),
            std::forward_as_tuple(std::forward<Projection>(projection)));
    }
    constexpr auto arg( {…}

    template <
        std::size_t first,
        std::size_t... others,
        typename Matcher,
        typename... Projections>
    [[nodiscard]]
    constexpr auto args(Matcher&& matcher, Projections&&... projections)
        noexcept(
            std::is_nothrow_constructible_v<std::remove_cvref_t<Matcher>, Matcher>
            && (... && std::is_nothrow_move_constructible_v<std::remove_cvref_t<Projections>>))
    {
        static_assert(
            sizeof...(projections) <= 1u + sizeof...(others),
            "The projection count exceeds the amount of indices.");
 
        return detail::make_args_policy<first, others...>(
            std::forward<Matcher>(matcher),
            mimicpp::detail::expand_tuple<std::identity, 1u + sizeof...(others)>(
                std::forward_as_tuple(std::forward<Projections>(projections)...)));
    }
    constexpr auto args(Matcher&& matcher, Projections&&... projections) {…}

    template <typename Matcher>
    [[nodiscard]]
    constexpr auto all_args(Matcher&& matcher)
        noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Matcher>, Matcher>)
    {
        using arg_selector_t = mimicpp::detail::all_args_selector_fn<std::add_lvalue_reference_t>;
        using apply_strategy_t = mimicpp::detail::arg_list_forward_apply_fn;
        using describe_strategy_t = detail::all_args_requirement_describer;
 
        return expectation_policies::ArgsRequirement{
            std::forward<Matcher>(matcher),
            mimicpp::detail::apply_args_fn(
                arg_selector_t{},
                apply_strategy_t{}),
            describe_strategy_t{}};
    }
    constexpr auto all_args(Matcher&& matcher) {…}

}
namespace mimicpp::expect {…}
 
#endif