ExpectationPolicies.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_EXPECTATION_POLICIES_HPP
#define MIMICPP_EXPECTATION_POLICIES_HPP
 
#pragma once
 
#include "mimic++/Expectation.hpp"
#include "mimic++/Matcher.hpp"
#include "mimic++/Printer.hpp"
#include "mimic++/Utility.hpp"
 
#include <cassert>
#include <functional>
 
namespace mimicpp::expectation_policies
{
    class InitFinalize
    {
    public:
        template <typename Return, typename... Args>
        static constexpr void finalize_call(const call::Info<Return, Args...>&) noexcept
        {
        }
    };
 
    template <ValueCategory expected>
    class Category
    {
    public:
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
 
        template <typename Return, typename... Args>
        static constexpr bool matches(const call::Info<Return, Args...>& info) noexcept
        {
            return mimicpp::is_matching(info.fromCategory, expected);
        }
 
        template <typename Return, typename... Args>
        static constexpr void consume([[maybe_unused]] const call::Info<Return, Args...>& info) noexcept
        {
            assert(mimicpp::is_matching(info.fromCategory, expected) && "Call does not match.");
        }
 
        [[nodiscard]]
        static StringT describe()
        {
            return format::format(
                "expect: from {} category overload",
                expected);
        }
    };
 
    template <Constness constness>
    class Constness
    {
    public:
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
 
        template <typename Return, typename... Args>
        static constexpr bool matches(const call::Info<Return, Args...>& info) noexcept
        {
            return mimicpp::is_matching(info.fromConstness, constness);
        }
 
        template <typename Return, typename... Args>
        static constexpr void consume([[maybe_unused]] const call::Info<Return, Args...>& info) noexcept
        {
            assert(mimicpp::is_matching(info.fromConstness, constness) && "Call does not match.");
        }
 
        [[nodiscard]]
        static StringT describe()
        {
            return format::format(
                "expect: from {} qualified overload",
                constness);
        }
    };
 
    template <typename Action>
        requires std::same_as<Action, std::remove_cvref_t<Action>>
                && std::is_move_constructible_v<Action>
    class ReturnsResultOf
    {
    public:
        [[nodiscard]]
        explicit constexpr ReturnsResultOf(
            Action&& action
        ) noexcept(std::is_nothrow_move_constructible_v<Action>)
            : m_Action{std::move(action)}
        {
        }
 
        template <typename Return, typename... Args>
            requires std::invocable<Action&, const call::Info<Return, Args...>&>
                    && explicitly_convertible_to<
                        std::invoke_result_t<Action&, const call::Info<Return, Args...>&>,
                        Return>
        [[nodiscard]]
        constexpr Return finalize_call(
            [[maybe_unused]] const call::Info<Return, Args...>& call
        ) noexcept(
            std::is_nothrow_invocable_v<Action&, const call::Info<Return, Args...>&>
            && nothrow_explicitly_convertible_to<
                std::invoke_result_t<Action&, const call::Info<Return, Args...>&>,
                Return>)
        {
            return static_cast<Return>(
                std::invoke(m_Action, call));
        }
 
    private:
        Action m_Action;
    };
 
    template <typename Exception>
        requires (!std::is_reference_v<Exception>)
                && std::copyable<Exception>
    class Throws
    {
    public:
        [[nodiscard]]
        explicit constexpr Throws(Exception exception) noexcept(std::is_nothrow_move_constructible_v<Exception>)
            : m_Exception{std::move(exception)}
        {
        }
 
        template <typename Return, typename... Args>
        constexpr Return finalize_call(
            [[maybe_unused]] const call::Info<Return, Args...>& call
        )
        {
            throw m_Exception;  // NOLINT(hicpp-exception-baseclass)
        }
 
    private:
        Exception m_Exception;
    };
 
    template <typename Matcher, typename Projection, typename Describer>
        requires std::same_as<Matcher, std::remove_cvref_t<Matcher>>
                && std::same_as<Projection, std::remove_cvref_t<Projection>>
                && std::same_as<Describer, std::remove_cvref_t<Describer>>
                && std::is_move_constructible_v<Matcher>
                && std::is_move_constructible_v<Projection>
                && std::is_move_constructible_v<Describer>
    class Requirement
    {
    public:
        [[nodiscard]]
        explicit constexpr Requirement(
            Matcher matcher,
            Projection projection = {},
            Describer describer = {}
        ) noexcept(
            std::is_nothrow_move_constructible_v<Matcher>
            && std::is_nothrow_move_constructible_v<Projection>
            && std::is_nothrow_move_constructible_v<Describer>)
            : m_Matcher{std::move(matcher)},
            m_Projection{std::move(projection)},
            m_Describer{std::move(describer)}
        {
        }
 
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
 
        template <typename Return, typename... Args>
            requires std::invocable<const Projection&, const call::Info<Return, Args...>&>
                    && matcher_for<
                        Matcher,
                        std::invoke_result_t<const Projection&, const call::Info<Return, Args...>&>>
        [[nodiscard]]
        constexpr bool matches(const call::Info<Return, Args...>& info) const
        {
            decltype(auto) projected = std::invoke(m_Projection, info);
            return detail::matches_hook::matches(
                m_Matcher,
                projected);
        }
 
        template <typename Return, typename... Args>
        static constexpr void consume([[maybe_unused]] const call::Info<Return, Args...>& info) noexcept
        {
        }
 
        [[nodiscard]]
        StringT describe() const
        {
            return std::invoke(
                m_Describer,
                detail::describe_hook::describe(m_Matcher));
        }
 
    private:
        [[no_unique_address]] Matcher m_Matcher;
        [[no_unique_address]] Projection m_Projection;
        [[no_unique_address]] Describer m_Describer;
    };
 
    template <typename Action>
    class SideEffectAction
    {
    public:
        ~SideEffectAction() = default;
 
        [[nodiscard]]
        explicit constexpr SideEffectAction(
            Action&& action
        ) noexcept(std::is_nothrow_move_constructible_v<Action>)
            : m_Action{std::move(action)}
        {
        }
 
        SideEffectAction(const SideEffectAction&) = delete;
        SideEffectAction& operator =(const SideEffectAction&) = delete;
 
        [[nodiscard]]
        SideEffectAction(SideEffectAction&&) = default;
        SideEffectAction& operator =(SideEffectAction&&) = default;
 
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
 
        template <typename Return, typename... Args>
        [[nodiscard]]
        static constexpr bool matches(const call::Info<Return, Args...>&) noexcept
        {
            return true;
        }
 
        [[nodiscard]]
        static std::nullopt_t describe() noexcept
        {
            return std::nullopt;
        }
 
        template <typename Return, typename... Args>
            requires std::invocable<Action&, const call::Info<Return, Args...>&>
        constexpr void consume(
            const call::Info<Return, Args...>& info
        ) noexcept(std::is_nothrow_invocable_v<Action&, const call::Info<Return, Args...>&>)
        {
            std::invoke(m_Action, info);
        }
 
    private:
        Action m_Action;
    };
 
    template <typename Action, template <typename> typename Projection>
        requires std::same_as<Action, std::remove_cvref_t<Action>>
    class ApplyAllArgsAction
    {
    public:
        [[nodiscard]]
        explicit constexpr ApplyAllArgsAction(
            Action action = {}
        ) noexcept(std::is_nothrow_move_constructible_v<Action>)
            : m_Action{std::move(action)}
        {
        }
 
        template <typename Arg>
        using ProjectedArgT = Projection<Arg>;
 
        template <typename Return, typename... Args>
            requires std::invocable<
                const Action&,
                ProjectedArgT<Args>...>
        constexpr decltype(auto) operator ()(
            const call::Info<Return, Args...>& callInfo
        ) const noexcept(
            std::is_nothrow_invocable_v<
                const Action&,
                ProjectedArgT<Args>...>)
        {
            static_assert(
                (... && explicitly_convertible_to<Args&, ProjectedArgT<Args>>),
                "Projection can not be applied.");
 
            return std::apply(
                [this](auto&... args) -> decltype(auto)
                {
                    return std::invoke(
                        m_Action,
                        static_cast<ProjectedArgT<Args>>(
                            args.get())...);
                },
                callInfo.args);
        }
 
    private:
        Action m_Action;
    };
 
    template <typename Action, template <typename> typename Projection, std::size_t... indices>
        requires std::same_as<Action, std::remove_cvref_t<Action>>
    class ApplyArgsAction
    {
    public:
        [[nodiscard]]
        explicit constexpr ApplyArgsAction(
            Action action = {}
        ) noexcept(std::is_nothrow_move_constructible_v<Action>)
            : m_Action{std::move(action)}
        {
        }
 
        template <std::size_t index, typename... Args>
        using ArgListElementT = std::tuple_element_t<index, std::tuple<Args...>>;
 
        template <std::size_t index, typename... Args>
        using ProjectedArgListElementT = Projection<ArgListElementT<index, Args...>>;
 
        template <typename Return, typename... Args>
            requires (... && (indices < sizeof...(Args)))
                    && std::invocable<
                        const Action&,
                        ProjectedArgListElementT<indices, Args...>...>
        constexpr decltype(auto) operator ()(
            const call::Info<Return, Args...>& callInfo
        ) const noexcept(
            std::is_nothrow_invocable_v<
                const Action&,
                ProjectedArgListElementT<indices, Args...>...>)
        {
            static_assert(
                (explicitly_convertible_to<
                        ArgListElementT<indices, Args...>&,
                        ProjectedArgListElementT<indices, Args...>>
                    && ...),
                "Projection can not be applied.");
 
            return std::invoke(
                m_Action,
                static_cast<ProjectedArgListElementT<indices, Args...>>(
                    std::get<indices>(callInfo.args).get())...);
        }
 
    private:
        [[no_unique_address]] Action m_Action;
    };
}
 
namespace mimicpp::expect
{
    namespace detail
    {
        template <std::size_t index>
        struct arg_requirement_describer
        {
            [[nodiscard]]
            constexpr StringT operator ()(
                const StringViewT matcherDescription
            ) const
            {
                return format::format(
                    "expect: arg[{}] {}",
                    index,
                    matcherDescription);
            }
        };
    }
 
    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_move_constructible_v<Projection>)
    {
        using ProjectionT = expectation_policies::ApplyArgsAction<
            Projection,
            std::add_lvalue_reference_t,
            index>;
        using PolicyT = expectation_policies::Requirement<
            std::remove_cvref_t<Matcher>,
            ProjectionT,
            detail::arg_requirement_describer<index>>;
 
        return PolicyT{
            std::forward<Matcher>(matcher),
            ProjectionT{std::move(projection)}
        };
    }
 
}
 
namespace mimicpp::finally
{
    // ReSharper disable CppDoxygenUnresolvedReference
 
    template <typename Fun>
        requires std::invocable<std::remove_cvref_t<Fun>&>
                && (!std::is_void_v<std::invoke_result_t<std::remove_cvref_t<Fun>&>>)
    [[nodiscard]]
    constexpr auto returns_result_of(
        Fun&& fun
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Fun>, Fun>)
    {
        return expectation_policies::ReturnsResultOf{
            [
                fn = std::forward<Fun>(fun)
            ]([[maybe_unused]] const auto& call) mutable noexcept(std::is_nothrow_invocable_v<decltype(fun)>) -> decltype(auto)
            {
                return std::invoke(fn);
            }
        };
    }
 
    template <typename T>
        requires std::copyable<std::remove_cvref_t<T>>
    [[nodiscard]]
    constexpr auto returns(
        T&& value  // NOLINT(cppcoreguidelines-missing-std-forward)
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<T>, T>)
    {
        return expectation_policies::ReturnsResultOf{
            [v = std::forward<T>(value)]([[maybe_unused]] const auto& call) mutable noexcept -> auto& {
                return static_cast<std::unwrap_reference_t<decltype(v)>&>(v);
            }
        };
    }
 
    template <std::size_t index, std::size_t... otherIndices, typename Action>
    [[nodiscard]]
    constexpr auto returns_apply_result_of(
        Action&& action
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        using ActionT = expectation_policies::ApplyArgsAction<
            std::remove_cvref_t<Action>,
            std::add_lvalue_reference_t,
            index,
            otherIndices...>;
 
        return expectation_policies::ReturnsResultOf{
            ActionT{std::forward<Action>(action)}
        };
    }
 
    template <typename Action>
    [[nodiscard]]
    constexpr auto returns_apply_all_result_of(
        Action&& action
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        using ActionT = expectation_policies::ApplyAllArgsAction<
            std::remove_cvref_t<Action>,
            std::add_lvalue_reference_t>;
 
        return expectation_policies::ReturnsResultOf{
            ActionT{std::forward<Action>(action)}
        };
    }
 
    template <std::size_t index>
    [[nodiscard]]
    constexpr auto returns_arg() noexcept
    {
        using ActionT = expectation_policies::ApplyArgsAction<
            std::identity,
            std::add_rvalue_reference_t,
            index>;
 
        return expectation_policies::ReturnsResultOf{
            ActionT{}
        };
    }
 
    template <typename T>
        requires std::copyable<std::remove_cvref_t<T>>
    [[nodiscard]]
    constexpr expectation_policies::Throws<std::remove_cvref_t<T>> throws(
        T&& exception
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<T>, T>)
    {
        return expectation_policies::Throws<std::remove_cvref_t<T>>{
            std::forward<T>(exception)
        };
    }
 
    // ReSharper restore CppDoxygenUnresolvedReference
}
 
namespace mimicpp::then
{
    template <std::size_t index, typename Action>
    [[nodiscard]]
    constexpr auto apply_arg(
        Action&& action
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        using ActionT = expectation_policies::ApplyArgsAction<
            std::remove_cvref_t<Action>,
            std::add_lvalue_reference_t,
            index>;
 
        return expectation_policies::SideEffectAction{
            ActionT{std::forward<Action>(action)}
        };
    }
 
    template <std::size_t index, std::size_t... additionalIndices, typename Action>
    [[nodiscard]]
    constexpr auto apply_args(
        Action&& action
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        using ActionT = expectation_policies::ApplyArgsAction<
            std::remove_cvref_t<Action>,
            std::add_lvalue_reference_t,
            index,
            additionalIndices...>;
 
        return expectation_policies::SideEffectAction{
            ActionT{std::forward<Action>(action)}
        };
    }
 
    template <typename Action>
    [[nodiscard]]
    constexpr auto apply_all(
        Action&& action
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        using ActionT = expectation_policies::ApplyAllArgsAction<
            std::remove_cvref_t<Action>,
            std::add_lvalue_reference_t>;
 
        return expectation_policies::SideEffectAction{
            ActionT{std::forward<Action>(action)}
        };
    }
 
    template <std::invocable Action>
    [[nodiscard]]
    constexpr auto invoke(
        Action&& action
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        return expectation_policies::SideEffectAction{
            [
                fn = std::forward<Action>(action)
            ]([[maybe_unused]] const auto& call) mutable noexcept(std::is_nothrow_invocable_v<Action&>)
            {
                std::invoke(fn);
            }
        };
    }
 
}
 
#endif