RequirementPolicies.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024-2026.
// 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_EXPECTATION_POLICIES_ARG_REQUIREMENT_POLICIES_HPP
#define MIMICPP_EXPECTATION_POLICIES_ARG_REQUIREMENT_POLICIES_HPP
 
#pragma once
 
#include "mimic++/config/Config.hpp"
#include "mimic++/expectation/Common.hpp"
#include "mimic++/expectation/policies/ArgumentList.hpp"
#include "mimic++/matchers/Common.hpp"
#include "mimic++/utilities/Concepts.hpp"
#include "mimic++/utilities/TypeList.hpp"
#include "mimic++/utilities/UnwrapRef.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
    {
        using matches_fn = mimicpp::detail::matches_hook::matches_fn;
 
    public:
        Matcher const& matcher;
 
        template <typename... Args>
            requires std::invocable<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
        MatchResult operator()(Args&&... args) const
            noexcept(std::is_nothrow_invocable_v<matches_fn, Matcher const&, Args&...>)
        {
            return mimicpp::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<MatchResult, MatchesStrategy const&, matcher_matches_fn<Matcher>, call::Info<Return, Args...> const&>
        [[nodiscard]]
        MatchResult matches(call::Info<Return, Args...> const& info) const
            noexcept(std::is_nothrow_invocable_v<MatchesStrategy const&, matcher_matches_fn<Matcher>, call::Info<Return, Args...> const&>)
        {
            matcher_matches_fn<Matcher> const matches{m_Matcher};
            auto result = std::invoke(m_MatchesStrategy, matches, info);
            std::visit(
                [&](auto& inner) {
                    if (auto& description = inner.description)
                    {
                        description = std::invoke(m_DescribeStrategy, *description);
                    }
                },
                result);
 
            return result;
        }
 
        template <typename Return, typename... Args>
        static constexpr void consume([[maybe_unused]] call::Info<Return, Args...> const& info) noexcept
        {
        }
 
    private:
        Matcher m_Matcher;
        [[no_unique_address]] MatchesStrategy m_MatchesStrategy;
        [[no_unique_address]] DescribeStrategy m_DescribeStrategy;
    };
 
    template <typename Target, typename Matcher>
        requires matcher_for<Matcher, Target>
    class ThatRequirement
    {
    public:
        ThatRequirement(ThatRequirement const&) = delete;
        ThatRequirement& operator=(ThatRequirement const&) = delete;
 
        ~ThatRequirement() = default;
 
        [[nodiscard]]
        ThatRequirement(ThatRequirement&&) = default;
        ThatRequirement& operator=(ThatRequirement&&) = default;
 
        [[nodiscard]]
        explicit constexpr ThatRequirement(Target target, Matcher condition)
            noexcept(std::is_nothrow_move_constructible_v<Target> && std::is_nothrow_move_constructible_v<Matcher>)
            : m_Target{std::move(target)},
              m_Matcher{std::move(condition)}
        {
        }
 
        [[nodiscard]]
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
 
        template <typename Return, typename... Args>
        [[nodiscard]]
        MatchResult matches(call::Info<Return, Args...> const& /*call*/) const
        {
            return mimicpp::detail::matches_hook::matches(m_Matcher, util::unwrap_ref(m_Target));
        }
 
        template <typename Return, typename... Args>
        static constexpr void consume(call::Info<Return, Args...> const& /*call*/) noexcept
        {
        }
 
    private:
        Target m_Target;
        Matcher m_Matcher;
    };
}
 
namespace mimicpp::expectation::policies::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 = args_selector_fn<
            std::add_lvalue_reference_t,
            std::index_sequence<indices...>>;
        using apply_strategy_t = arg_list_indirect_apply_fn<std::remove_cvref_t<Projections>...>;
        using describe_strategy_t = arg_requirement_describer<indices...>;
 
        return ArgsRequirement{
            std::forward<Matcher>(matcher),
            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 expectation::policies::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 expectation::policies::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 = expectation::policies::detail::all_args_selector_fn<std::add_lvalue_reference_t>;
        using apply_strategy_t = expectation::policies::detail::arg_list_forward_apply_fn;
        using describe_strategy_t = expectation::policies::detail::all_args_requirement_describer;
 
        return expectation::policies::ArgsRequirement{
            std::forward<Matcher>(matcher),
            expectation::policies::detail::apply_args_fn(arg_selector_t{}, apply_strategy_t{}),
            describe_strategy_t{}};
    }

    template <typename Target, matcher_for<Target> Matcher>
    [[nodiscard]]
    constexpr auto that(Target&& target, Matcher&& matcher)
    {
        return expectation::policies::ThatRequirement{std::forward<Target>(target), std::forward<Matcher>(matcher)};
    }

}
 
#endif