catch3
Progmasoft Catch3: an independently maintained C++17 test framework with a parallel runner, property checks, snapshots and structured results.
Clonegit clone https://git.progmasoft.com/catch3
develroot / src / Progmasoft / Catch3 / Mock.hpp
// Copyright (c) 2026 Progmasoft.
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
#include <Progmasoft/Catch3/Internal/Enforce.hpp>
#include <Progmasoft/Catch3/Internal/SourceLineInfo.hpp>
#include <Progmasoft/Catch3/Matchers/Matchers.hpp>
#include <Progmasoft/Catch3/Matchers/Templated.hpp>
#include <Progmasoft/Catch3/Matchers/Vector.hpp>
#include <Progmasoft/Catch3/ToString.hpp>
#include <cstddef>
#include <exception>
#include <functional>
#include <limits>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
namespace Progmasoft::Catch3
{
template<typename Signature>
class MockExpectation;
template<typename Signature>
class MockFunction;
namespace Detail
{
inline constexpr std::size_t kUnlimitedCalls
= std::numeric_limits<std::size_t>::max();
class MockSequence;
/// What the checks need to know of an expectation, whatever the
/// signature of its mock.
struct MockExpectationState final
{
std::string Description;
Catch::SourceLineInfo Line;
std::size_t Minimum = 1;
std::size_t Maximum = 1;
std::size_t Calls = 0;
bool Retired = false;
std::vector<std::shared_ptr<MockSequence>> Sequences;
MockExpectationState(std::string description,
const Catch::SourceLineInfo &line)
: Description(std::move(description))
, Line(line)
{}
[[nodiscard]] bool
Satisfied() const noexcept
{
return Calls >= Minimum;
}
/// Whether the expectation can take one more call.
[[nodiscard]] bool
Available() const noexcept
{
return !Retired && Calls < Maximum;
}
};
/// The steps of a sequence. It does not keep them alive: a step whose
/// mock is gone was verified with that mock.
class MockSequence final
{
public:
void
Add(const std::shared_ptr<MockExpectationState> &step);
/// Moves to `step`, retiring the steps before it. Returns what
/// was left undone, empty when the call came in order.
[[nodiscard]] std::string
Enter(const MockExpectationState &step);
private:
std::vector<std::weak_ptr<MockExpectationState>> steps;
std::size_t current = 0;
};
/// All mocks share one lock, since a sequence can span them.
[[nodiscard]] std::unique_lock<std::recursive_mutex>
LockMocks();
/// Fails the running test case at `line` and never throws, since a
/// mock can stand in for a `noexcept` function or be in a destructor.
/// Outside of a test case the message goes to standard error.
void
ReportMockFailure(const Catch::SourceLineInfo &line,
const std::string &mock,
std::string message);
/// Fails the running test case and leaves it, for a call nothing can
/// return from. In a `noexcept` function that ends the process.
[[noreturn]] void
AbortMockCall(const Catch::SourceLineInfo &line,
const std::string &mock,
std::string message);
/// Counts a met expectation as a passed assertion.
void
ReportMockSuccess(const Catch::SourceLineInfo &line,
const std::string &mock,
std::string message);
/// "exactly 2 calls", "at least 1 call", "any number of calls".
[[nodiscard]] std::string
DescribeCalls(std::size_t minimum, std::size_t maximum);
/// "called once" and the like, for a report.
[[nodiscard]] std::string
DescribeCount(std::size_t calls);
template<std::size_t Index, typename Signature>
struct MockArgumentOf;
template<std::size_t Index, typename... Arguments>
struct MockArgumentOf<Index, void(Arguments...)>
{
using Type = std::tuple_element_t<Index, std::tuple<Arguments...>>;
};
/// The type of a parameter of a mocked method.
template<std::size_t Index, typename Signature>
using MockArgument = typename MockArgumentOf<Index, Signature>::Type;
template<typename T>
struct IsComposedMatcher: std::false_type
{
};
template<typename T>
struct IsComposedMatcher<Catch::Matchers::Detail::MatchAllOf<T>>
: std::true_type
{
};
template<typename T>
struct IsComposedMatcher<Catch::Matchers::Detail::MatchAnyOf<T>>
: std::true_type
{
};
template<typename T>
struct IsComposedMatcher<Catch::Matchers::Detail::MatchNotOf<T>>
: std::true_type
{
};
template<typename... Ts>
struct IsComposedMatcher<
Catch::Matchers::Detail::MatchAllOfGeneric<Ts...>>: std::true_type
{
};
template<typename... Ts>
struct IsComposedMatcher<
Catch::Matchers::Detail::MatchAnyOfGeneric<Ts...>>: std::true_type
{
};
template<typename T>
struct IsComposedMatcher<Catch::Matchers::Detail::MatchNotOfGeneric<T>>
: std::true_type
{
};
/// Catch's vector matchers refer to what they compare with.
template<typename T>
struct HoldsReference: std::false_type
{
};
template<typename T, typename Alloc>
struct HoldsReference<
Catch::Matchers::VectorContainsElementMatcher<T, Alloc>>
: std::true_type
{
};
template<typename T, typename AllocComp, typename AllocMatch>
struct HoldsReference<
Catch::Matchers::ContainsMatcher<T, AllocComp, AllocMatch>>
: std::true_type
{
};
template<typename T, typename AllocComp, typename AllocMatch>
struct HoldsReference<
Catch::Matchers::EqualsMatcher<T, AllocComp, AllocMatch>>
: std::true_type
{
};
template<typename T, typename AllocComp, typename AllocMatch>
struct HoldsReference<
Catch::Matchers::ApproxMatcher<T, AllocComp, AllocMatch>>
: std::true_type
{
};
template<typename T, typename AllocComp, typename AllocMatch>
struct HoldsReference<
Catch::Matchers::UnorderedEqualsMatcher<T, AllocComp, AllocMatch>>
: std::true_type
{
};
/// Whether two integers have the same value, whatever their types.
template<typename Left, typename Right>
[[nodiscard]] constexpr bool
SameInteger(Left left, Right right) noexcept
{
if constexpr (std::is_signed_v<Left> == std::is_signed_v<Right>)
{
return left == right;
}
else if constexpr (std::is_signed_v<Left>)
{
return left >= 0
&& static_cast<std::make_unsigned_t<Left>>(left)
== right;
}
else
{
return right >= 0
&& left
== static_cast<std::make_unsigned_t<Right>>(
right);
}
}
/// How one argument of a call is judged.
template<typename Argument>
struct ArgumentMatcher final
{
std::function<bool(const Argument &)> Test;
std::string Description;
};
} // namespace Detail
/// Accepts any value of an argument.
struct AnyArgument final
{};
inline constexpr AnyArgument Any{};
/// Accepts the values `predicate` accepts; `description` names it in
/// reports.
template<typename Predicate>
struct WhereArgument final
{
Predicate Test;
std::string Description;
};
template<typename Predicate>
[[nodiscard]] WhereArgument<std::decay_t<Predicate>>
Where(Predicate &&predicate, std::string description)
{
return { std::forward<Predicate>(predicate), std::move(description) };
}
namespace Detail
{
template<typename Argument, typename Expected>
[[nodiscard]] ArgumentMatcher<Argument>
MakeArgumentMatcher(Expected &&expected)
{
using Stored = std::decay_t<Expected>;
if constexpr (std::is_same_v<Stored, AnyArgument>)
{
return { [](const Argument &) {
return true;
},
"any" };
}
else if constexpr (std::is_base_of_v<
Catch::Matchers::MatcherUntypedBase,
Stored>)
{
static_assert(!IsComposedMatcher<Stored>::value,
"A composed matcher refers to temporaries that "
"are gone when the mock is called; use Where.");
static_assert(!HoldsReference<Stored>::value,
"A vector matcher refers to its vector, which "
"can be gone when the mock is called; use "
"Where.");
auto matcher = std::make_shared<Stored>(
std::forward<Expected>(expected));
auto description = matcher->toString();
return { [matcher](const Argument &value) {
return matcher->match(value);
},
std::move(description) };
}
else if constexpr (!std::is_null_pointer_v<Stored>
&& std::is_constructible_v<std::string, Stored>
&& std::is_constructible_v<std::string,
Argument>)
{
// Strings are compared by value, also as `const char *`.
if constexpr (std::is_pointer_v<Stored>)
{
if (expected == nullptr)
{
return { []([[maybe_unused]] const Argument &value) {
if constexpr (std::is_pointer_v<Argument>)
{
return value == nullptr;
}
else
{
return false;
}
},
"nullptr" };
}
}
std::string text{ std::forward<Expected>(expected) };
auto description = Catch::Detail::stringify(text);
return { [text = std::move(text)](const Argument &value) {
if constexpr (std::is_pointer_v<Argument>)
{
return value != nullptr && text == value;
}
else
{
return text == value;
}
},
std::move(description) };
}
else if constexpr (std::is_integral_v<Argument>
&& std::is_integral_v<Stored>
&& !std::is_same_v<Argument, bool>
&& !std::is_same_v<Stored, bool>)
{
// A literal is an int, whatever the type of the parameter.
const Stored value = expected;
return { [value](const Argument &argument) {
return SameInteger(argument, value);
},
Catch::Detail::stringify(value) };
}
else
{
auto description = Catch::Detail::stringify(expected);
return { [value = std::forward<Expected>(expected)](
const Argument &argument) {
return argument == value;
},
std::move(description) };
}
}
template<typename Argument, typename Predicate>
[[nodiscard]] ArgumentMatcher<Argument>
MakeArgumentMatcher(WhereArgument<Predicate> where)
{
return { std::move(where.Test), std::move(where.Description) };
}
} // namespace Detail
/// Calls that have to come in the order their expectations were declared
/// in, across mocks.
class Sequence final
{
public:
Sequence()
: state(std::make_shared<Detail::MockSequence>())
{}
private:
template<typename Signature>
friend class MockExpectation;
std::shared_ptr<Detail::MockSequence> state;
};
/// One expected kind of call of a mock. It expects one call until told
/// otherwise.
template<typename Result, typename... Arguments>
class MockExpectation<Result(Arguments...)> final
{
public:
MockExpectation &
Times(std::size_t count)
{
return Between(count, count);
}
MockExpectation &
AtLeast(std::size_t count)
{
return Between(count, Detail::kUnlimitedCalls);
}
MockExpectation &
AtMost(std::size_t count)
{
return Between(0, count);
}
MockExpectation &
AnyTimes()
{
return Between(0, Detail::kUnlimitedCalls);
}
MockExpectation &
Never()
{
return Between(0, 0);
}
MockExpectation &
Between(std::size_t minimum, std::size_t maximum)
{
CATCH_ENFORCE(minimum <= maximum,
"A mock expectation needs its minimum at most its "
"maximum");
const auto lock = Detail::LockMocks();
state->Minimum = minimum;
state->Maximum = maximum;
return *this;
}
/// Takes this step in `sequence`, after the ones declared before it.
MockExpectation &
InSequence(const Sequence &sequence)
{
const auto lock = Detail::LockMocks();
sequence.state->Add(state);
state->Sequences.push_back(sequence.state);
return *this;
}
/// Returns `value`. A type that cannot be copied is moved out on the
/// first call; a reference result refers to `value`, which has to
/// outlive the mock.
template<typename Value>
MockExpectation &
Returns(Value &&value)
{
static_assert(!std::is_void_v<Result>,
"A mock of a void function returns nothing.");
if constexpr (std::is_reference_v<Result>)
{
static_assert(std::is_lvalue_reference_v<Value>,
"A reference result needs an object that "
"outlives the mock.");
auto *target = &value;
return Does([target](Arguments...) -> Result {
return static_cast<Result>(*target);
});
}
else if constexpr (std::is_copy_constructible_v<Result>)
{
return Does([held = static_cast<Result>(std::forward<Value>(
value))](Arguments...) -> Result {
return held;
});
}
else
{
auto held
= std::make_shared<Result>(std::forward<Value>(value));
return Does([held](Arguments...) -> Result {
// Calls can come from several threads.
const auto lock = Detail::LockMocks();
return std::move(*held);
});
}
}
/// Runs `action` with the arguments of each call; what it returns is
/// what the call returns.
template<typename Action>
MockExpectation &
Does(Action &&work)
{
const auto lock = Detail::LockMocks();
action = std::make_shared<std::function<Result(Arguments...)>>(
std::forward<Action>(work));
return *this;
}
/// Throws `exception` from each call.
template<typename Exception>
MockExpectation &
Throws(Exception exception)
{
return Does(
[exception = std::move(exception)](Arguments...) -> Result {
Catch::throw_exception(exception);
});
}
/// What the arguments of a call have to match.
using Matchers
= std::tuple<Detail::ArgumentMatcher<std::decay_t<Arguments>>...>;
private:
template<typename Signature>
friend class MockFunction;
MockExpectation(std::string description,
const Catch::SourceLineInfo &line,
std::unique_ptr<Matchers> accepted)
: state(std::make_shared<Detail::MockExpectationState>(
std::move(description),
line))
, matchers(std::move(accepted))
{}
template<std::size_t... Indices>
[[nodiscard]] bool
Accepts([[maybe_unused]] const std::tuple<
const std::decay_t<Arguments> &...> &values,
std::index_sequence<Indices...>) const
{
return (std::get<Indices>(*matchers).Test(std::get<Indices>(values))
&& ...);
}
[[nodiscard]] bool
Accepts(
const std::tuple<const std::decay_t<Arguments> &...> &values) const
{
return matchers == nullptr
|| Accepts(values, std::index_sequence_for<Arguments...>{});
}
std::shared_ptr<Detail::MockExpectationState> state;
// Empty when any arguments will do.
std::unique_ptr<Matchers> matchers;
std::shared_ptr<std::function<Result(Arguments...)>> action;
};
/// A mock of one function: a callable that checks its calls against the
/// expectations set on it and fails the running test case when they do
/// not hold. It is what `CATCH3_MOCK_METHOD` declares, and on its own it
/// stands in for a free function behind a seam. Its destructor verifies
/// it.
template<typename Result, typename... Arguments>
class MockFunction<Result(Arguments...)> final
{
using Expectation = MockExpectation<Result(Arguments...)>;
public:
/// Declares an expectation at `line`; called with what the arguments
/// have to match. See `CATCH3_EXPECT_CALL`.
class ExpectationStart final
{
public:
template<typename... Expected>
Expectation &
operator()(Expected &&...expected)
{
constexpr auto arguments = sizeof...(Arguments);
static_assert(sizeof...(Expected) == 0
|| sizeof...(Expected) == arguments,
"Match every argument of the mock, or none to "
"accept any.");
if constexpr (sizeof...(Expected) == arguments
&& arguments != 0)
{
return mock.Add(
line,
std::make_unique<typename Expectation::Matchers>(
Detail::MakeArgumentMatcher<
std::decay_t<Arguments>>(
std::forward<Expected>(expected))...));
}
else
{
return mock.Add(line, nullptr);
}
}
private:
friend class MockFunction;
ExpectationStart(MockFunction &function,
const Catch::SourceLineInfo &place)
: mock(function)
, line(place)
{}
MockFunction &mock;
Catch::SourceLineInfo line;
};
/// `place` is where a call no expectation takes is reported when the
/// mock has no expectations to point at.
explicit MockFunction(std::string mockName = "mock",
const Catch::SourceLineInfo &place
= CATCH_INTERNAL_LINEINFO)
: name(std::move(mockName))
, declared(place)
, exceptions(std::uncaught_exceptions())
{}
MockFunction(const MockFunction &) = delete;
MockFunction &
operator=(const MockFunction &) = delete;
~MockFunction()
{
// A test case that is being left has failed for its own reason,
// and what it did not get to call says nothing more.
if (std::uncaught_exceptions() <= exceptions)
{
VerifyAll();
}
}
[[nodiscard]] ExpectationStart
Expect(const Catch::SourceLineInfo &line)
{
return { *this, line };
}
/// Checks the expectations now and forgets them, so that a test case
/// can go on with new ones.
void
Verify()
{
VerifyAll();
}
Result
operator()(Arguments... arguments)
{
const Decision decision = Decide(
std::tuple<const std::decay_t<Arguments> &...>{ arguments... });
if (!decision.line)
{
return Refuse(decision.message);
}
if (!decision.message.empty())
{
Detail::ReportMockFailure(*decision.line,
name,
decision.message);
}
if (decision.action != nullptr)
{
return (*decision.action)(
std::forward<Arguments>(arguments)...);
}
if constexpr (std::is_void_v<Result>)
{
return;
}
else if constexpr (std::is_default_constructible_v<Result>)
{
return Result{};
}
else
{
Detail::AbortMockCall(*decision.line,
name,
"nothing to return from " + name
+ ": give the expectation Returns "
"or Does");
}
}
/// A function that calls this mock, which has to outlive it.
[[nodiscard]] std::function<Result(Arguments...)>
AsFunction()
{
return [this](Arguments... arguments) -> Result {
return (*this)(std::forward<Arguments>(arguments)...);
};
}
private:
struct Decision final
{
// Empty when the call is refused.
std::optional<Catch::SourceLineInfo> line;
std::shared_ptr<std::function<Result(Arguments...)>> action;
std::string message;
};
Expectation &
Add(const Catch::SourceLineInfo &line,
std::unique_ptr<typename Expectation::Matchers> matchers)
{
auto description = Describe(matchers.get());
const auto lock = Detail::LockMocks();
expectations.push_back(std::unique_ptr<Expectation>(
new Expectation(std::move(description),
line,
std::move(matchers))));
return *expectations.back();
}
template<std::size_t... Indices>
[[nodiscard]] std::string
DescribeMatchers(
[[maybe_unused]] const typename Expectation::Matchers &matchers,
std::index_sequence<Indices...>) const
{
std::string text;
((text += (Indices == 0 ? "" : ", ")
+ std::get<Indices>(matchers).Description),
...);
return text;
}
[[nodiscard]] std::string
Describe(const typename Expectation::Matchers *matchers) const
{
if (matchers != nullptr)
{
return name + "("
+ DescribeMatchers(
*matchers,
std::index_sequence_for<Arguments...>{})
+ ")";
}
return sizeof...(Arguments) == 0 ? name + "()" : name + "(...)";
}
template<std::size_t... Indices>
[[nodiscard]] std::string
DescribeCall([[maybe_unused]] const std::tuple<
const std::decay_t<Arguments> &...> &values,
std::index_sequence<Indices...>) const
{
std::string text = name + "(";
((text += (Indices == 0 ? "" : ", ")
+ Catch::Detail::stringify(std::get<Indices>(values))),
...);
return text + ")";
}
/// Picks the first declared expectation that accepts the call and can
/// take it, and counts the call.
[[nodiscard]] Decision
Decide(const std::tuple<const std::decay_t<Arguments> &...> &values)
{
const auto lock = Detail::LockMocks();
const Expectation *used = nullptr;
for (const auto &expectation : expectations)
{
if (!expectation->Accepts(values))
{
continue;
}
if (expectation->state->Available())
{
return Take(*expectation);
}
used = expectation.get();
}
const auto call
= DescribeCall(values, std::index_sequence_for<Arguments...>{});
Decision refused;
refused.message = used != nullptr ? DescribeUsed(call, *used->state)
: DescribeUnexpected(call);
return refused;
}
[[nodiscard]] Decision
Take(const Expectation &expectation)
{
auto &state = *expectation.state;
++state.Calls;
Decision decision;
decision.line = state.Line;
decision.action = expectation.action;
for (const auto &sequence : state.Sequences)
{
decision.message += sequence->Enter(state);
}
return decision;
}
[[nodiscard]] static std::string
DescribeUsed(const std::string &call,
const Detail::MockExpectationState &state)
{
return state.Retired ? "call out of order: " + call
+ ", its step of the sequence has passed"
: "too many calls: " + call + ", expected "
+ Detail::DescribeCalls(state.Minimum,
state.Maximum)
+ " of " + state.Description;
}
[[nodiscard]] std::string
DescribeUnexpected(const std::string &call) const
{
std::string text = "unexpected call: " + call;
if (expectations.empty())
{
return text + ", nothing was expected of this mock";
}
text += ", expected";
for (const auto &expectation : expectations)
{
text += "\n " + expectation->state->Description;
}
return text;
}
/// Reports a call no expectation takes, and returns what the call
/// can return.
Result
Refuse(const std::string &message)
{
const auto line = FirstLine();
if constexpr (std::is_void_v<Result>)
{
Detail::ReportMockFailure(line, name, message);
}
else if constexpr (std::is_default_constructible_v<Result>)
{
Detail::ReportMockFailure(line, name, message);
return Result{};
}
else
{
Detail::AbortMockCall(line, name, message);
}
}
/// Where to point at for a call that matches nothing: the first
/// expectation, or the mock when it has none.
[[nodiscard]] Catch::SourceLineInfo
FirstLine() const
{
const auto lock = Detail::LockMocks();
return expectations.empty() ? declared
: expectations.front()->state->Line;
}
void
VerifyAll()
{
std::vector<std::unique_ptr<Expectation>> checked;
{
const auto lock = Detail::LockMocks();
checked.swap(expectations);
}
for (const auto &expectation : checked)
{
const auto &state = *expectation->state;
if (state.Satisfied())
{
Detail::ReportMockSuccess(state.Line,
name,
state.Description);
}
else
{
Detail::ReportMockFailure(
state.Line,
name,
"unmet expectation: " + state.Description + " needs "
+ Detail::DescribeCalls(state.Minimum,
state.Maximum)
+ ", " + Detail::DescribeCount(state.Calls));
}
}
}
std::string name;
Catch::SourceLineInfo declared;
int exceptions;
std::vector<std::unique_ptr<Expectation>> expectations;
};
/// Points a seam, a `std::function` or a function pointer that production
/// code calls through, at `replacement` until the end of the scope.
template<typename Seam>
class ScopedSeam final
{
public:
ScopedSeam(Seam &target, std::enable_if_t<true, Seam> replacement)
: seam(target)
, original(std::move(target))
{
seam = std::move(replacement);
}
ScopedSeam(const ScopedSeam &) = delete;
ScopedSeam &
operator=(const ScopedSeam &) = delete;
~ScopedSeam()
{
seam = std::move(original);
}
private:
Seam &seam;
Seam original;
};
} // namespace Progmasoft::Catch3
// How many types a parenthesized list holds, up to 8, including none. A type
// with a comma of its own needs an alias.
#define CATCH3_INTERNAL_MOCK_EXPAND(...) __VA_ARGS__
#define CATCH3_INTERNAL_MOCK_CONCAT_IMPL(a, b) a##b
#define CATCH3_INTERNAL_MOCK_CONCAT(a, b) CATCH3_INTERNAL_MOCK_CONCAT_IMPL(a, b)
#define CATCH3_INTERNAL_MOCK_FIRST(first, ...) first
#define CATCH3_INTERNAL_MOCK_SECOND_OF(first, second, ...) second
#define CATCH3_INTERNAL_MOCK_SECOND(...) \
CATCH3_INTERNAL_MOCK_EXPAND(CATCH3_INTERNAL_MOCK_SECOND_OF(__VA_ARGS__))
#define CATCH3_INTERNAL_MOCK_PROBE(...) ~, 1
#define CATCH3_INTERNAL_MOCK_IS_EMPTY(argument) \
CATCH3_INTERNAL_MOCK_EXPAND( \
CATCH3_INTERNAL_MOCK_SECOND(CATCH3_INTERNAL_MOCK_PROBE argument(), \
0, ))
#define CATCH3_INTERNAL_MOCK_SELECT(a1, \
a2, \
a3, \
a4, \
a5, \
a6, \
a7, \
a8, \
a9, \
count, \
...) \
count
#define CATCH3_INTERNAL_MOCK_COUNT_0(...) \
CATCH3_INTERNAL_MOCK_EXPAND(CATCH3_INTERNAL_MOCK_SELECT(__VA_ARGS__, \
9, \
8, \
7, \
6, \
5, \
4, \
3, \
2, \
1, \
0))
#define CATCH3_INTERNAL_MOCK_COUNT_1(...) 0
#define CATCH3_INTERNAL_MOCK_COUNT(...) \
CATCH3_INTERNAL_MOCK_EXPAND(CATCH3_INTERNAL_MOCK_CONCAT( \
CATCH3_INTERNAL_MOCK_COUNT_, \
CATCH3_INTERNAL_MOCK_IS_EMPTY(CATCH3_INTERNAL_MOCK_EXPAND( \
CATCH3_INTERNAL_MOCK_FIRST(__VA_ARGS__, ))))(__VA_ARGS__))
#define CATCH3_INTERNAL_MOCK_ARGUMENT(signature, index) \
::Progmasoft::Catch3::Detail::MockArgument<index, signature>
#define CATCH3_INTERNAL_MOCK_PARAMETER(signature, index) \
CATCH3_INTERNAL_MOCK_ARGUMENT(signature, index) argument##index
#define CATCH3_INTERNAL_MOCK_FORWARD(signature, index) \
static_cast<CATCH3_INTERNAL_MOCK_ARGUMENT(signature, index) &&>( \
argument##index)
#define CATCH3_INTERNAL_MOCK_LIST_0(each, s)
#define CATCH3_INTERNAL_MOCK_LIST_1(each, s) each(s, 0)
#define CATCH3_INTERNAL_MOCK_LIST_2(each, s) \
CATCH3_INTERNAL_MOCK_LIST_1(each, s), each(s, 1)
#define CATCH3_INTERNAL_MOCK_LIST_3(each, s) \
CATCH3_INTERNAL_MOCK_LIST_2(each, s), each(s, 2)
#define CATCH3_INTERNAL_MOCK_LIST_4(each, s) \
CATCH3_INTERNAL_MOCK_LIST_3(each, s), each(s, 3)
#define CATCH3_INTERNAL_MOCK_LIST_5(each, s) \
CATCH3_INTERNAL_MOCK_LIST_4(each, s), each(s, 4)
#define CATCH3_INTERNAL_MOCK_LIST_6(each, s) \
CATCH3_INTERNAL_MOCK_LIST_5(each, s), each(s, 5)
#define CATCH3_INTERNAL_MOCK_LIST_7(each, s) \
CATCH3_INTERNAL_MOCK_LIST_6(each, s), each(s, 6)
#define CATCH3_INTERNAL_MOCK_LIST_8(each, s) \
CATCH3_INTERNAL_MOCK_LIST_7(each, s), each(s, 7)
#define CATCH3_INTERNAL_MOCK_LIST(count, each, signature) \
CATCH3_INTERNAL_MOCK_CONCAT(CATCH3_INTERNAL_MOCK_LIST_, count) \
(each, signature)
#define CATCH3_INTERNAL_MOCK_DECLARE(result, \
name, \
field, \
arguments, \
count, \
specifiers) \
result name(CATCH3_INTERNAL_MOCK_LIST(count, \
CATCH3_INTERNAL_MOCK_PARAMETER, \
void arguments)) specifiers \
{ \
return field(CATCH3_INTERNAL_MOCK_LIST(count, \
CATCH3_INTERNAL_MOCK_FORWARD, \
void arguments)); \
} \
mutable ::Progmasoft::Catch3::MockFunction<result arguments> field \
{ \
#name, CATCH_INTERNAL_LINEINFO \
}
#define CATCH3_INTERNAL_MOCK_SPLIT(result, name, field, arguments, ...) \
CATCH3_INTERNAL_MOCK_EXPAND(CATCH3_INTERNAL_MOCK_DECLARE( \
result, \
name, \
field, \
arguments, \
CATCH3_INTERNAL_MOCK_EXPAND(CATCH3_INTERNAL_MOCK_COUNT arguments), \
CATCH3_INTERNAL_MOCK_EXPAND( \
CATCH3_INTERNAL_MOCK_FIRST(__VA_ARGS__, ))))
/// Declares the member `name` of a mock class and, beside it, the mock
/// `name##Mock` that `CATCH3_EXPECT_CALL` takes. The parenthesized list of
/// parameter types comes next, and then what goes after the parameters:
/// `CATCH3_MOCK_METHOD(int, Get, (const Key &), const override);`. A type with
/// a comma in it needs an alias.
#define CATCH3_MOCK_METHOD(result, name, ...) \
CATCH3_MOCK_OVERLOAD(result, name, name##Mock, __VA_ARGS__)
/// `CATCH3_MOCK_METHOD` for one of several overloads, whose mock needs a name
/// of its own: `field`.
#define CATCH3_MOCK_OVERLOAD(result, name, field, ...) \
CATCH3_INTERNAL_MOCK_EXPAND( \
CATCH3_INTERNAL_MOCK_SPLIT(result, name, field, __VA_ARGS__, ))
/// Declares a `MockFunction` called `name` with a signature:
/// `CATCH3_MOCK_FUNCTION(clock, long());`.
#define CATCH3_MOCK_FUNCTION(name, ...) \
::Progmasoft::Catch3::MockFunction<__VA_ARGS__> name \
{ \
#name, CATCH_INTERNAL_LINEINFO \
}
/// Expects a call of `mock`, a `MockFunction`, and takes what its arguments
/// have to match: values, Catch matchers, `Any` or `Where`, or nothing to
/// accept any. Failures of the expectation point at this line.
#define CATCH3_EXPECT_CALL(mock) (mock).Expect(CATCH_INTERNAL_LINEINFO)