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++/config/Config.hpp"
#include "mimic++/matchers/Common.hpp"
#include "mimic++/policies/ArgumentList.hpp"
#include "mimic++/utilities/Concepts.hpp"
#include "mimic++/utilities/TypeList.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <concepts>
    #include <cstddef>
    // ReSharper disable once CppUnusedIncludeDirective
    #include <functional> // std::invoke
    #include <tuple>
    #include <type_traits>
    #include <utility>
#endif
 
namespace mimicpp::expectation_policies
{
    template <typename Matcher>
    struct matcher_matches_fn
    {
    public:
        Matcher const& matcher;
 
        template <typename... Args>
            requires std::invocable<detail::matches_hook::matches_fn, Matcher const&, 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),
                    Matcher const&,
                    Args&...>)
        {
            return detail::matches_hook::matches(matcher, args...);
        }
    };
 
    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)}
        {
        }
 
        [[nodiscard]]
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
 
        template <typename Return, typename... Args>
            requires std::is_invocable_r_v<bool, MatchesStrategy const&, matcher_matches_fn<Matcher>, call::Info<Return, Args...> const&>
        [[nodiscard]]
        constexpr bool matches(const call::Info<Return, Args...>& info) const
            noexcept(std::is_nothrow_invocable_v<MatchesStrategy const&, matcher_matches_fn<Matcher>, call::Info<Return, Args...> const&>)
        {
            return std::invoke(
                m_MatchesStrategy,
                matcher_matches_fn<Matcher>{m_Matcher},
                info);
        }
 
        template <typename Return, typename... Args>
        static constexpr void consume([[maybe_unused]] call::Info<Return, Args...> const& info) noexcept
        {
        }
 
        [[nodiscard]]
        std::optional<StringT> describe() const
        {
            [[maybe_unused]] auto const description = detail::describe_hook::describe(m_Matcher);
 
            if constexpr (util::boolean_testable<decltype(description)>)
            {
                if (description)
                {
                    return std::invoke(m_DescribeStrategy, *description);
                }
 
                return std::nullopt;
            }
            else if constexpr (std::convertible_to<decltype(description), StringViewT>)
            {
                return std::invoke(m_DescribeStrategy, description);
            }
            else
            {
                return std::nullopt;
            }
        }
 
    private:
        Matcher m_Matcher;
        [[no_unique_address]] MatchesStrategy m_MatchesStrategy;
        [[no_unique_address]] DescribeStrategy m_DescribeStrategy;
    };
}
 
namespace mimicpp::expect::detail
{
    template <std::size_t index, std::size_t... others>
    struct arg_requirement_describer
    {
        [[nodiscard]]
        StringT operator()(StringViewT const 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()(StringViewT const 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{}};
    }
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::expect
{

    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)));
    }

    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),
            util::detail::expand_tuple<std::identity, 1u + sizeof...(others)>(
                std::forward_as_tuple(std::forward<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{}};
    }

}
 
#endif