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::detail
{
    [[nodiscard]]
    inline StringT describe_times_state(const std::size_t current, const std::size_t min, const std::size_t max)
    {
        const auto verbalizeValue = [](const std::size_t value)-> StringT
        {
            switch (value)
            {
            case 0:
                return "never";
            case 1:
                return "once";
            case 2:
                return "twice";
            default:
                return format::format("{} times", value);
            }
        };
 
        if (current == max)
        {
            return format::format(
                "inapplicable: already saturated (matched {})",
                verbalizeValue(current));
        }
 
        if (min <= current)
        {
            return format::format(
                "applicable: accepts further matches (matched {} out of {} times)",
                current,
                max);
        }
 
        const auto verbalizeInterval = [verbalizeValue](const std::size_t start, const std::size_t end)
        {
            if (start < end)
            {
                return format::format(
                    "between {} and {} times",
                    start,
                    end);
            }
 
            return format::format(
                "exactly {}",
                verbalizeValue(end));
        };
 
        return format::format(
            "unsatisfied: matched {} - {} is expected",
            verbalizeValue(current),
            verbalizeInterval(min, max));
    }
}
 
namespace mimicpp::expectation_policies
{
    class InitFinalize
    {
    public:
        template <typename Return, typename... Args>
        static constexpr void finalize_call(const call::Info<Return, Args...>&) noexcept
        {
        }
    };
 
    class Times
    {
    public:
        [[nodiscard]]
        constexpr explicit Times(const std::size_t min, const std::size_t max)
            : m_Min{min},
            m_Max{max}
        {
            if (m_Max < m_Min)
            {
                throw std::invalid_argument{"min must be less or equal to max."};
            }
        }
 
        [[nodiscard]]
        constexpr bool is_satisfied() const noexcept
        {
            return m_Min <= m_Count
                    && m_Count <= m_Max;
        }
 
        [[nodiscard]]
        constexpr bool is_applicable() const noexcept
        {
            return m_Count < m_Max;
        }
 
        [[nodiscard]]
        StringT describe_state() const
        {
            return detail::describe_times_state(
                m_Count,
                m_Min,
                m_Max);
        }
 
        constexpr void consume() noexcept
        {
            ++m_Count;
        }
 
    private:
        std::size_t m_Min;
        std::size_t m_Max;
        std::size_t m_Count{};
    };
 
    class InitTimes
        : public Times
    {
    public:
        [[nodiscard]]
        consteval InitTimes() noexcept
            : Times{1u, 1u}
        {
        }
    };
 
    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(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(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 = Projection{},
            Describer 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
        {
            return m_Matcher.matches(
                std::invoke(m_Projection, info));
        }
 
        template <typename Return, typename... Args>
        static constexpr void consume([[maybe_unused]] const call::Info<Return, Args...>& info) noexcept
        {
        }
 
        [[nodiscard]]
        std::optional<StringT> describe() const
        {
            if (const std::optional<StringT> description = m_Matcher.describe())
            {
                return std::invoke(
                    m_Describer,
                    *description);
            }
 
            return std::nullopt;
        }
 
    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 = 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 = 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:
        Action m_Action;
    };
}
 
namespace mimicpp::expectation_policies::detail
{
    struct forward_fn
    {
        template <typename T>
        [[nodiscard]]
        constexpr T&& operator ()(T&& obj) const noexcept
        {
            return std::forward<T>(obj);
        }
    };
}
 
namespace mimicpp::expect
{
    template <std::size_t min, std::size_t max = min>
        requires (min <= max)
    [[nodiscard]]
    consteval auto times() noexcept
    {
        return expectation_policies::Times{
            min,
            max
        };
    }
 
    [[nodiscard]]
    constexpr auto times(const std::size_t min, const std::size_t max)
    {
        return expectation_policies::Times{min, max};
    }
 
    [[nodiscard]]
    constexpr auto times(const std::size_t exactly) noexcept
    {
        return times(exactly, exactly);
    }
 
    template <std::size_t min>
    [[nodiscard]]
    consteval auto at_least() noexcept
    {
        return expectation_policies::Times{
            min,
            std::numeric_limits<std::size_t>::max()
        };
    }
 
    [[nodiscard]]
    constexpr auto at_least(const std::size_t min) noexcept
    {
        return expectation_policies::Times{min, std::numeric_limits<std::size_t>::max()};
    }
 
    template <std::size_t max>
    [[nodiscard]]
    consteval auto at_most() noexcept
    {
        return expectation_policies::Times{
            0u,
            max
        };
    }
 
    [[nodiscard]]
    constexpr auto at_most(const std::size_t max) noexcept
    {
        return expectation_policies::Times{0u, max};
    }
 
    [[nodiscard]]
    consteval auto once() noexcept
    {
        return expectation_policies::Times{
            1u,
            1u
        };
    }
 
    [[nodiscard]]
    consteval auto twice() noexcept
    {
        return expectation_policies::Times{
            2u,
            2u
        };
    }
 
    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>
    [[nodiscard]]
    constexpr auto arg(
        Matcher&& matcher
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Matcher>, Matcher&&>)
    {
        return expectation_policies::Requirement<
            std::remove_cvref_t<Matcher>,
            expectation_policies::ApplyArgsAction<
                expectation_policies::detail::forward_fn,
                std::add_lvalue_reference_t,
                index>,
            detail::arg_requirement_describer<index>>{
            std::forward<Matcher>(matcher),
        };
    }
 
}
 
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  // NOLINT(cppcoreguidelines-missing-std-forward)
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Fun>, Fun>)
    {
        return expectation_policies::ReturnsResultOf{
            [
                fun = std::forward<Fun>(fun)
            ]([[maybe_unused]] const auto& call) mutable noexcept(std::is_nothrow_invocable_v<decltype(fun)>) -> decltype(auto)
            {
                return std::invoke(fun);
            }
        };
    }
 
    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>)
    {
        return expectation_policies::ReturnsResultOf{
            expectation_policies::ApplyArgsAction<
                std::remove_cvref_t<Action>,
                std::add_lvalue_reference_t,
                index,
                otherIndices...>{
                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>)
    {
        return expectation_policies::ReturnsResultOf{
            expectation_policies::ApplyAllArgsAction<
                std::remove_cvref_t<Action>,
                std::add_lvalue_reference_t>{
                std::forward<Action>(action)
            }
        };
    }
 
    template <std::size_t index>
    [[nodiscard]]
    constexpr auto returns_arg() noexcept
    {
        return expectation_policies::ReturnsResultOf{
            expectation_policies::ApplyArgsAction<
                expectation_policies::detail::forward_fn,
                std::add_rvalue_reference_t,
                index>{
                expectation_policies::detail::forward_fn{}
            }
        };
    }
 
    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>)
    {
        return expectation_policies::SideEffectAction{
            expectation_policies::ApplyArgsAction<
                std::remove_cvref_t<Action>,
                std::add_lvalue_reference_t,
                index>{
                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>)
    {
        return expectation_policies::SideEffectAction{
            expectation_policies::ApplyArgsAction<
                std::remove_cvref_t<Action>,
                std::add_lvalue_reference_t,
                index,
                additionalIndices...>{
                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>)
    {
        return expectation_policies::SideEffectAction{
            expectation_policies::ApplyAllArgsAction<
                std::remove_cvref_t<Action>,
                std::add_lvalue_reference_t>{
                std::forward<Action>(action)
            }
        };
    }
 
    template <std::invocable Action>
    [[nodiscard]]
    constexpr auto invoke(
        Action&& action  // NOLINT(cppcoreguidelines-missing-std-forward)
    ) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        return expectation_policies::SideEffectAction{
            [
                action = std::forward<Action>(action)
            ]([[maybe_unused]] const auto& call) mutable noexcept(std::is_nothrow_invocable_v<Action&>)
            {
                std::invoke(action);
            }
        };
    }
 
}
 
#endif