GeneralPolicies.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_GENERAL_POLICIES_HPP
#define MIMICPP_EXPECTATION_POLICIES_GENERAL_POLICIES_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/expectation/Common.hpp"
#include "mimic++/printing/StatePrinter.hpp"
#include "mimic++/utilities/C++23Backports.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <iterator>
    #include <optional>
    #include <utility>
#endif
 
namespace mimicpp::detail
{
    [[nodiscard]]
    constexpr bool is_matching(Constness const lhs, Constness const rhs) noexcept
    {
        return std::cmp_not_equal(0, util::to_underlying(lhs) & util::to_underlying(rhs));
    }
 
    [[nodiscard]]
    constexpr bool is_matching(ValueCategory const lhs, ValueCategory const rhs) noexcept
    {
        return std::cmp_not_equal(0, util::to_underlying(lhs) & util::to_underlying(rhs));
    }
}
 
namespace mimicpp::expectation::policies
{
    class InitFinalize
    {
    public:
        template <typename Return, typename... Args>
        static constexpr void finalize_call(call::Info<Return, Args...> const&) noexcept
        {
        }
    };
 
    template <ValueCategory expected>
    class Category
    {
    public:
        [[nodiscard]]
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
 
        template <typename Return, typename... Args>
        [[nodiscard]]
        static MatchResult matches(call::Info<Return, Args...> const& info) noexcept
        {
            if (mimicpp::detail::is_matching(info.fromCategory, expected))
            {
                return MatchSuccess{.description = describe()};
            }
 
            return MatchFailure{.description = describe()};
        }
 
        template <typename Return, typename... Args>
        static constexpr void consume([[maybe_unused]] call::Info<Return, Args...> const& info) noexcept
        {
            MIMICPP_ASSERT(mimicpp::detail::is_matching(info.fromCategory, expected), "Call does not match.");
        }
 
    private:
        [[nodiscard]]
        static auto describe()
        {
            if constexpr (ValueCategory::any != expected)
            {
                StringStreamT stream{};
                stream << "expect: from ";
                mimicpp::print(std::ostreambuf_iterator{stream}, expected);
                stream << " category overload";
 
                return std::move(stream).str();
            }
            else
            {
                return std::nullopt;
            }
        }
    };
 
    template <Constness constness>
    class Constness
    {
    public:
        [[nodiscard]]
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
 
        template <typename Return, typename... Args>
        [[nodiscard]]
        static MatchResult matches(call::Info<Return, Args...> const& info) noexcept
        {
            if (mimicpp::detail::is_matching(info.fromConstness, constness))
            {
                return MatchSuccess{.description = describe()};
            }
 
            return MatchFailure{.description = describe()};
        }
 
        template <typename Return, typename... Args>
        static constexpr void consume([[maybe_unused]] call::Info<Return, Args...> const& info) noexcept
        {
            MIMICPP_ASSERT(mimicpp::detail::is_matching(info.fromConstness, constness), "Call does not match.");
        }
 
    private:
        [[nodiscard]]
        static auto describe()
        {
            if constexpr (mimicpp::Constness::any != constness)
            {
                StringStreamT stream{};
                stream << "expect: from ";
                mimicpp::print(std::ostreambuf_iterator{stream}, constness);
                stream << " qualified overload";
 
                return std::move(stream).str();
            }
            else
            {
                return std::nullopt;
            }
        }
    };
}
 
#endif