Common.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 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_COMMON_HPP
#define MIMICPP_EXPECTATION_COMMON_HPP
 
#pragma once
 
#include "mimic++/Call.hpp"
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/reporting/ExpectationReport.hpp"
#include "mimic++/utilities/Concepts.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <concepts>
    #include <type_traits>
    #include <utility>
    #include <variant>
#endif
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::expectation
{
    struct MatchSuccess
    {
        std::optional<StringT> description{};
 
        [[nodiscard]]
        friend bool operator==(MatchSuccess const&, MatchSuccess const&) = default;
    };
 
    struct MatchFailure
    {
        std::optional<StringT> description{};
 
        friend bool operator==(MatchFailure const&, MatchFailure const&) = default;
    };
 
    using MatchResult = std::variant<MatchSuccess, MatchFailure>;
    using MatchResults = std::vector<MatchResult>;

    template <typename T, typename Signature>
    concept expectation_policy_for = std::is_move_constructible_v<T>
                                  && std::is_destructible_v<T>
                                  && std::same_as<T, std::remove_cvref_t<T>>
                                  && requires(T& policy, call::info_for_signature_t<Signature> const& info) {
                                         { std::as_const(policy).is_satisfied() } noexcept -> util::boolean_testable;
                                         { std::as_const(policy).matches(info) } -> std::convertible_to<MatchResult>;
                                         { policy.consume(info) };
                                     };

    template <typename T, typename Signature>
    concept finalize_policy_for = std::is_move_constructible_v<T>
                               && std::is_destructible_v<T>
                               && std::same_as<T, std::remove_cvref_t<T>>
                               && requires(T& policy, call::info_for_signature_t<Signature> const& info) {
                                      { policy.finalize_call(info) } -> std::convertible_to<signature_return_type_t<Signature>>;
                                  };

    template <typename T>
    concept control_policy = std::is_move_constructible_v<T>
                          && std::is_destructible_v<T>
                          && std::same_as<T, std::remove_cvref_t<T>>
                          && requires(T& policy) {
                                 { std::as_const(policy).is_satisfied() } noexcept -> util::boolean_testable;
                                 { std::as_const(policy).state() } -> std::convertible_to<reporting::control_state_t>;
                                 policy.consume();
                             };
}
 
#endif