Sequoia
Loading...
Searching...
No Matches
Classes | Functions | Variables
sequoia::testing::impl Namespace Reference

Condition for applying a container check. More...

Classes

struct  allocation_actions
 actions common to both move-only and regular types. More...
 
struct  allocation_advice
 
class  allocation_checker
 Wraps allocation_info, together with the prior allocation count. More...
 
struct  auxiliary_data
 
struct  auxiliary_data_policy
 
struct  auxiliary_data_policy< T >
 
struct  do_swap
 
struct  do_swap< allocation_checker< T, Getters >... >
 
struct  do_swap< dual_allocation_checker< T, Getters >... >
 
struct  do_swap<>
 
class  dual_allocation_checker
 Wraps allocation_info, together with two prior allocation counts. More...
 
struct  move_only_allocation_actions
 
struct  node_equivalence_checker
 
struct  node_equivalence_checker< Nodes >
 
struct  node_value_tester
 
struct  node_value_tester< Nodes >
 
struct  null_mutator
 
struct  regular_allocation_actions
 Extends allocation_actions for types with copy semantics. More...
 

Functions

template<test_mode Mode, movable_comparable T, alloc_getter< T > Getter, auto Event>
bool check_allocation (std::string_view detail, test_logger< Mode > &logger, const T &container, const allocation_info< T, Getter > &info, const int previous, const alloc_prediction< Event > prediction)
 
template<movable_comparable T, alloc_getter< T > Getter>
 dual_allocation_checker (allocation_info< T, Getter >, const T &, const T &) -> dual_allocation_checker< T, Getter >
 
template<movable_comparable T, alloc_getter< T > Getter>
 allocation_checker (allocation_info< T, Getter >, const T &) -> allocation_checker< T, Getter >
 
template<movable_comparable T, alloc_getter< T > Getter>
 allocation_checker (allocation_info< T, Getter >, int) -> allocation_checker< T, Getter >
 
template<template< class, class > class Checker, movable_comparable T, alloc_getter< T > Getter, class... Args, std::size_t... I>
auto make_scoped_allocation_checkers (const allocation_info< T, Getter > &info, std::index_sequence< I... >, Args &&... args)
 
template<template< class, class > class Checker, movable_comparable T, alloc_getter< T > Getter, class... Args>
auto make_scoped_allocation_checkers (const allocation_info< T, Getter > &info, Args &&... args)
 
template<movable_comparable T, alloc_getter< T > Getter, class... Args>
std::tuple< dual_allocation_checker< T, Getter > > make_dual_allocation_checkers (const allocation_info< T, Getter > &info, Args &&... args)
 
template<movable_comparable T, alloc_getter< T > Getter, class... Args>
requires scoped_alloc<std::invoke_result_t<Getter, T>>
auto make_dual_allocation_checkers (const allocation_info< T, Getter > &info, Args &&... args)
 
template<movable_comparable T, alloc_getter< T > Getter, class... Args>
std::tuple< allocation_checker< T, Getter > > make_allocation_checkers (const allocation_info< T, Getter > &info, Args &&... args)
 
template<movable_comparable T, alloc_getter< T > Getter, class... Args>
requires scoped_alloc<std::invoke_result_t<Getter, T>>
auto make_allocation_checkers (const allocation_info< T, Getter > &info, Args &&... args)
 
template<auto AllocEvent, test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_no_allocation (std::string_view detail, test_logger< Mode > &logger, const T &x, const T &y, const dual_allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_copy_assign_allocation (test_logger< Mode > &logger, const T &x, const T &y, const dual_allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_move_assign_allocation (test_logger< Mode > &logger, const T &x, const dual_allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_mutation_after_swap (test_logger< Mode > &logger, const T &x, const T &y, const dual_allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, std::invocable< T & > Mutator, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_mutation_after_swap (test_logger< Mode > &logger, T &lhs, const T &rhs, const T &y, Mutator yMutator, dual_allocation_checker< T, Getters >... checkers)
 
template<auto AllocEvent, test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_no_allocation (test_logger< Mode > &logger, const T &container, std::string_view tag, const allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_copy_x_allocation (test_logger< Mode > &logger, const T &container, const allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_copy_y_allocation (test_logger< Mode > &logger, const T &container, const allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_move_y_allocation (test_logger< Mode > &logger, const T &container, const allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_mutation_allocation (std::string_view priorOp, test_logger< Mode > &logger, const T &y, const allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_para_copy_y_allocation (test_logger< Mode > &logger, const T &container, const allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_para_copy_y_allocation (test_logger< Mode > &logger, const T &container, std::tuple< allocation_checker< T, Getters >... > checkers)
 
template<test_mode Mode, container_tag tag, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_para_move_allocation (test_logger< Mode > &logger, container_tag_constant< tag >, const T &container, const allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, container_tag tag, movable_comparable T, alloc_getter< T >... Getters>
void check_para_move_allocation (test_logger< Mode > &logger, container_tag_constant< tag >, const T &container, std::tuple< allocation_checker< T, Getters >... > checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_initialization_allocations (test_logger< Mode > &logger, const T &x, const T &y, const allocation_info< T, Getters > &... info)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_init_allocations (test_logger< Mode > &logger, const T &x, const T &y, const allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
void check_init_allocations (test_logger< Mode > &logger, const T &x, const T &y, std::tuple< allocation_checker< T, Getters >... > checkers)
 
template<test_mode Mode, movable_comparable T, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_serialization_allocation (test_logger< Mode > &logger, const T &container, const allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, class Actions , moveonly T, class U , alloc_getter< T >... Getters>
requires checkable_against_for_semantics<Mode, T, U>
bool check_swap (test_logger< Mode > &logger, const Actions &actions, T &&x, T &&y, const U &xEquivalent, const U &yEquivalent, const dual_allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, container_tag tag, moveonly T, class U , alloc_getter< T >... Getters>
requires checkable_against_for_semantics<Mode, T, U>
std::optional< T > check_para_constructor_allocations (test_logger< Mode > &logger, container_tag_constant< tag >, T &&z, const U &zEquivalent, const allocation_info< T, Getters > &... info)
 
template<test_mode Mode, moveonly T, class U , alloc_getter< T >... Getters>
requires checkable_against_for_semantics<Mode, T, U>
std::pair< std::optional< T >, std::optional< T > > check_para_constructor_allocations (test_logger< Mode > &logger, T &&x, T &&y, const U &xEquivalent, const U &yEquivalent, const allocation_info< T, Getters > &... info)
 
template<test_mode Mode, class Actions , moveonly T, class U , std::invocable< T & > Mutator, alloc_getter< T >... Getters>
requires checkable_against_for_semantics<Mode, T, U> && (sizeof...(Getters) > 0)
void check_semantics (std::string description, test_logger< Mode > &logger, const Actions &actions, T &&x, T &&y, const U &xEquivalent, const U &yEquivalent, optional_ref< const U > movedFromPostConstruction, optional_ref< const U > movedFromPostAssignment, Mutator m, const allocation_info< T, Getters > &... info)
 
template<test_mode Mode, class Actions , moveonly T, invocable_r< T > xMaker, invocable_r< T > yMaker, std::invocable< T & > Mutator, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
std::pair< T, T > check_semantics (std::string description, test_logger< Mode > &logger, const Actions &actions, xMaker xFn, yMaker yFn, optional_ref< const T > movedFromPostConstruction, optional_ref< const T > movedFromPostAssignment, Mutator m, const allocation_info< T, Getters > &... info)
 
template<test_mode Mode, class Actions , moveonly T, class U , std::invocable< T & > Mutator, alloc_getter< T >... Getters>
requires checkable_against_for_semantics<Mode, T, U> && (sizeof...(Getters) > 0)
void check_semantics (test_logger< Mode > &logger, const Actions &actions, T &&x, T &&y, const U &xEquivalent, const U &yEquivalent, optional_ref< const U > movedFromPostConstruction, optional_ref< const U > movedFromPostAssignment, Mutator m, std::tuple< dual_allocation_checker< T, Getters >... > checkers)
 Unpacks the tuple and feeds to the overload of check_semantics defined in MoveOnlyCheckersDetails.hpp.
 
template<test_mode Mode, class Actions , moveonly T, class U , class V , std::invocable< T & > Mutator, class... Args>
requires checkable_against_for_semantics<Mode, T, U> && checkable_against_for_semantics<Mode, T, V>
bool check_semantics (test_logger< Mode > &logger, const Actions &actions, T &&x, T &&y, const U &xEquivalent, const U &yEquivalent, optional_ref< const V > movedFromPostConstruction, optional_ref< const V > movedFromPostAssignment, Mutator m, const Args &... args)
 
template<test_mode Mode, class Actions , pseudoregular T, alloc_getter< T >... Getters>
bool check_copy_assign (test_logger< Mode > &logger, const Actions &actions, T &z, const T &y, const dual_allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, pseudoregular T, std::invocable< T & > Mutator, alloc_getter< T >... Getters>
void check_para_constructor_allocations (test_logger< Mode > &logger, const T &y, Mutator yMutator, const allocation_info< T, Getters > &... info)
 
template<test_mode Mode, class Actions , pseudoregular T, std::invocable< T & > Mutator, alloc_getter< T >... Getters>
bool check_swap (test_logger< Mode > &logger, const Actions &actions, T &&x, T &&y, const T &xEquivalent, const T &yEquivalent, Mutator yMutator, const dual_allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, class Actions , pseudoregular T, std::invocable< T & > Mutator, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
void check_semantics (std::string description, test_logger< Mode > &logger, const Actions &actions, const T &x, const T &y, Mutator yMutator, const allocation_info< T, Getters > &... info)
 
template<test_mode Mode, class Actions , pseudoregular T, invocable_r< T > xMaker, invocable_r< T > yMaker, std::invocable< T & > Mutator, alloc_getter< T >... Getters>
requires (sizeof...(Getters) > 0)
std::pair< T, T > check_semantics (std::string description, test_logger< Mode > &logger, const Actions &actions, xMaker xFn, yMaker yFn, Mutator yMutator, const allocation_info< T, Getters > &... info)
 
template<test_mode Mode, class Actions , pseudoregular T, std::invocable< T & > Mutator, alloc_getter< T >... Getters>
bool check_semantics (test_logger< Mode > &logger, const Actions &actions, const T &x, const T &y, Mutator yMutator, std::tuple< dual_allocation_checker< T, Getters >... > checkers)
 Unpacks the tuple and feeds to the overload of check_semantics defined in RegularCheckersDetails.hpp.
 
template<test_mode Mode, class Actions , pseudoregular T, class... Args>
bool do_check_copy_assign (test_logger< Mode > &logger, const Actions &actions, T &z, const T &y, const Args &... args)
 
template<test_mode Mode, class Actions , pseudoregular T>
bool check_copy_assign (test_logger< Mode > &logger, const Actions &actions, T &z, const T &y)
 
template<test_mode Mode, class Actions , pseudoregular T, class U , std::invocable< T & > Mutator, class... Args>
bool check_semantics (test_logger< Mode > &logger, const Actions &actions, const T &x, const T &y, optional_ref< const U > movedFromPostConstruction, optional_ref< const U > movedFromPostAssignment, Mutator yMutator, const Args &... args)
 
template<test_mode Mode, class T , class U >
requires equivalence_checkable_for_semantics<Mode, T, U>
void check_best_equivalence (test_logger< Mode > &logger, const T &x, const T &y, const U &xEquivalent, const U &yEquivalent)
 
template<test_mode Mode, comparison_flavour C, class Actions , movable_comparable T, invocable_r< bool, T > Fn, class... Args>
bool do_check_comparison_consistency (test_logger< Mode > &logger, comparison_constant< C > comparison, const Actions &actions, const T &x, std::string_view tag, Fn fn, const Args &... args)
 
template<test_mode Mode, comparison_flavour C, class Actions , movable_comparable T, invocable_r< bool, T > Fn>
bool check_comparison_consistency (test_logger< Mode > &logger, comparison_constant< C > comparison, const Actions &actions, const T &x, const T &y, Fn fn)
 
template<test_mode Mode, class Actions , std::totally_ordered T, class... Args>
bool check_ordering_operators (test_logger< Mode > &logger, const Actions &actions, const T &x, const T &y, const Args &... args)
 
template<test_mode Mode, class Actions , std::totally_ordered T, class... Args>
bool check_ordering_consistency (test_logger< Mode > &logger, const Actions &actions, const T &x, const T &y, const Args &... args)
 
template<test_mode Mode, class Actions , std::totally_ordered T, class U , class... Args>
bool check_ordering_consistency (test_logger< Mode > &logger, const Actions &actions, const T &x, const T &y, const U &, const U &, const Args &... args)
 
template<test_mode Mode, class Actions , std::equality_comparable T, class... Args>
bool check_equality_prerequisites (test_logger< Mode > &logger, const Actions &actions, const T &x, const T &y, const Args &... args)
 
template<test_mode Mode, std::equality_comparable T, class U >
requires checkable_against_for_semantics<Mode, T, U>
bool check_against (std::string message, test_logger< Mode > &logger, const T &x, const U &xEquivalent)
 
template<test_mode Mode, class Actions , std::equality_comparable T, class U , class... Args>
bool check_equality_prerequisites (test_logger< Mode > &logger, const Actions &actions, const T &x, const T &y, const U &xEquivalent, const U &yEquivalent, const Args &... args)
 
template<test_mode Mode, class Actions , std::totally_ordered T, class... Args>
bool check_orderable_prerequisites (test_logger< Mode > &logger, const Actions &actions, const T &x, const T &y, const Args &... args)
 
template<test_mode Mode, class Actions , movable_comparable T, class U , class V , class... Args>
requires checkable_against_for_semantics<Mode, T, U> && checkable_against_for_semantics<Mode, T, V>
std::optional< T > do_check_move_construction (test_logger< Mode > &logger, const Actions &actions, T &&z, const U &y, optional_ref< const V > movedFrom, const Args &... args)
 
template<test_mode Mode, class Actions , movable_comparable T, class U , class V >
requires checkable_against_for_semantics<Mode, T, U>
std::optional< T > check_move_construction (test_logger< Mode > &logger, const Actions &actions, T &&z, const U &y, optional_ref< const V > movedFrom)
 
template<test_mode Mode, class Actions , movable_comparable T, class U , class V , std::invocable< T & > Mutator, class... Args>
requires checkable_against_for_semantics<Mode, T, U> && checkable_against_for_semantics<Mode, T, V>
void do_check_move_assign (test_logger< Mode > &logger, const Actions &actions, T &z, T &&y, const U &yEquivalent, optional_ref< const V > movedFrom, Mutator &&yMutator, const Args &... args)
 
template<test_mode Mode, class Actions , movable_comparable T, class U , class V , std::invocable< T & > Mutator>
requires checkable_against_for_semantics<Mode, T, U> && checkable_against_for_semantics<Mode, T, V>
void check_move_assign (test_logger< Mode > &logger, const Actions &actions, T &z, T &&y, const U &yEquivalent, optional_ref< const V > movedFrom, Mutator m)
 
template<test_mode Mode, class Actions , movable_comparable T, class U , class... Args>
requires checkable_against_for_semantics<Mode, T, U>
bool do_check_swap (test_logger< Mode > &logger, const Actions &actions, T &&x, T &&y, const U &xEquivalent, const U &yEquivalent, const Args &... args)
 
template<test_mode Mode, class Actions , movable_comparable T, class U >
requires checkable_against_for_semantics<Mode, T, U>
bool check_swap (test_logger< Mode > &logger, const Actions &actions, T &&x, T &&y, const U &xEquivalent, const U &yEquivalent)
 
template<test_mode Mode, class Actions , pseudoregular T, class U , std::invocable< T & > Mutator>
requires checkable_against_for_semantics<Mode, T, U>
bool check_swap (test_logger< Mode > &logger, const Actions &actions, T &&x, T &&y, const U &xEquivalent, const U &yEquivalent, Mutator yMutator)
 
template<test_mode Mode, class Actions , movable_comparable T, class... Args>
requires (serializable_to<T, std::stringstream> && deserializable_from<T, std::stringstream>)
bool do_check_serialization (test_logger< Mode > &logger, const Actions &actions, T &&u, const T &y, const Args &... args)
 
template<test_mode Mode, class Actions , movable_comparable T>
requires (serializable_to<T, std::stringstream> && deserializable_from<T, std::stringstream>)
bool check_serialization (test_logger< Mode > &logger, const Actions &actions, T &&u, const T &y)
 
template<class CheckType , test_mode Mode, class PartitionedData >
void check_details (CheckType flavour, test_logger< Mode > &logger, const PartitionedData &data, const PartitionedData &prediction)
 
template<test_mode Mode, class PartitionedData , class T = typename PartitionedData::value_type>
void check (equivalence_check_t, test_logger< Mode > &logger, const PartitionedData &data, std::initializer_list< std::initializer_list< T > > prediction)
 
template<class CheckerType , test_mode Mode, class Edge , class Prediction >
void check_partial (CheckerType flavour, test_logger< Mode > &logger, const Edge &edge, const Prediction &prediction)
 
template<test_mode Mode, class Edge , class Prediction >
void check_complementary (test_logger< Mode > &logger, const Edge &edge, const Prediction &prediction)
 
template<test_mode Mode, class T >
void check (test_logger< Mode > &logger, const T &sequence, const T &prediction)
 
OverloadSet

Functions for performing allocation checks which are common to types with both regular and move-only semantics. These functions provide an extra level of indirection in order that the current number of allocations may be acquired before proceeding

template<test_mode Mode, comparison_flavour C, class Actions , movable_comparable T, invocable_r< bool, T > Fn, class... Getters>
bool check_comparison_consistency (test_logger< Mode > &logger, comparison_constant< C > comparison, const Actions &actions, const T &x, const T &y, Fn fn, const dual_allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, class Actions , movable_comparable T, class U , alloc_getter< T >... Getters>
requires checkable_against_for_semantics<Mode, T, U> && (sizeof...(Getters) > 0)
std::optional< T > check_move_construction (test_logger< Mode > &logger, const Actions &actions, T &&z, const U &y, optional_ref< const U > movedFrom, const dual_allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, class Actions , movable_comparable T, class U , std::invocable< T & > Mutator, alloc_getter< T >... Getters>
requires checkable_against_for_semantics<Mode, T, U> && (sizeof...(Getters) > 0)
void check_move_assign (test_logger< Mode > &logger, const Actions &actions, T &u, T &&v, const U &y, optional_ref< const U > movedFrom, Mutator yMutator, const dual_allocation_checker< T, Getters > &... checkers)
 
template<test_mode Mode, movable_comparable T, std::invocable< T & > Mutator, class... Checkers>
void check_mutation_after_move (std::string_view moveType, test_logger< Mode > &logger, T &t, Mutator yMutator, Checkers... checkers)
 
template<test_mode Mode, movable_comparable T, std::invocable< T & > Mutator, class... Checkers, std::size_t... I>
void check_mutation_after_move (std::string_view moveType, test_logger< Mode > &logger, T &t, Mutator yMutator, std::tuple< Checkers... > checkers, std::index_sequence< I... >)
 
template<test_mode Mode, movable_comparable T, std::invocable< T & > Mutator, class... Checkers>
void check_mutation_after_move (std::string_view moveType, test_logger< Mode > &logger, T &t, Mutator yMutator, std::tuple< Checkers... > checkers)
 
template<test_mode Mode, class Actions , movable_comparable T, alloc_getter< T >... Getters>
bool check_serialization (test_logger< Mode > &logger, const Actions &actions, T &&u, const T &y, const dual_allocation_checker< T, Getters > &... checkers)
 

Variables

template<class CheckType , test_mode Mode, faithful_range T, faithful_range U, class Advisor >
constexpr bool supports_range_check_v
 
template<class Actions , class... Args>
constexpr bool has_post_copy_action
 
template<class Actions , class... Args>
constexpr bool has_post_copy_assign_action
 
template<class Actions , class... Args>
constexpr bool has_post_comparison_action
 
template<class Actions , class... Args>
constexpr bool has_post_move_action
 
template<class Actions , class... Args>
constexpr bool has_post_move_assign_action
 
template<class Actions , class... Args>
constexpr bool has_post_swap_action
 
template<class Actions , class... Args>
constexpr bool has_post_serialization_action
 

Detailed Description

Condition for applying a container check.

An extra level of indirection is required here to avoid recursive concept checks for type like filesystem which satisfy the range concept but not sequoia::faithul_range

Function Documentation

◆ check_copy_assign()

template<test_mode Mode, class Actions , pseudoregular T, alloc_getter< T >... Getters>
bool sequoia::testing::impl::check_copy_assign ( test_logger< Mode > &  logger,
const Actions &  actions,
T &  z,
const T &  y,
const dual_allocation_checker< T, Getters > &...  checkers 
)

Provides an extra level of indirection in order that the current number of allocation may be acquired before proceeding.

Variable Documentation

◆ has_post_comparison_action

template<class Actions , class... Args>
constexpr bool sequoia::testing::impl::has_post_comparison_action
inlineconstexpr
Initial value:
= requires (std::remove_cvref_t<Actions> actions, std::remove_cvref_t<Args>&... args) {
actions.post_comparison_action(args...);
}

◆ has_post_copy_action

template<class Actions , class... Args>
constexpr bool sequoia::testing::impl::has_post_copy_action
inlineconstexpr
Initial value:
= requires (std::remove_cvref_t<Actions> actions, std::remove_cvref_t<Args>&... args) {
actions.post_copy_action(args...);
}

◆ has_post_copy_assign_action

template<class Actions , class... Args>
constexpr bool sequoia::testing::impl::has_post_copy_assign_action
inlineconstexpr
Initial value:
= requires (std::remove_cvref_t<Actions> actions, std::remove_cvref_t<Args>&... args) {
actions.post_copy_assign_action(args...);
}

◆ has_post_move_action

template<class Actions , class... Args>
constexpr bool sequoia::testing::impl::has_post_move_action
inlineconstexpr
Initial value:
= requires (std::remove_cvref_t<Actions> actions, std::remove_cvref_t<Args>&... args) {
actions.post_move_action(args...);
}

◆ has_post_move_assign_action

template<class Actions , class... Args>
constexpr bool sequoia::testing::impl::has_post_move_assign_action
inlineconstexpr
Initial value:
= requires (std::remove_cvref_t<Actions> actions, std::remove_cvref_t<Args>&... args) {
actions.post_move_assign_action(args...);
}

◆ has_post_serialization_action

template<class Actions , class... Args>
constexpr bool sequoia::testing::impl::has_post_serialization_action
inlineconstexpr
Initial value:
= requires (std::remove_cvref_t<Actions> actions, std::remove_cvref_t<Args>&... args) {
actions.post_serialization_action(args...);
}

◆ has_post_swap_action

template<class Actions , class... Args>
constexpr bool sequoia::testing::impl::has_post_swap_action
inlineconstexpr
Initial value:
= requires (std::remove_cvref_t<Actions> actions, std::remove_cvref_t<Args>&... args) {
actions.post_swap_action(args...);
}

◆ supports_range_check_v

template<class CheckType , test_mode Mode, faithful_range T, faithful_range U, class Advisor >
constexpr bool sequoia::testing::impl::supports_range_check_v
inlineconstexpr
Initial value:
{
requires(T& t, U& u) {
requires supports_iterator_range_check<CheckType, Mode, decltype(std::ranges::begin(t)), decltype(std::ranges::begin(u)), Advisor>;
}
}
constexpr bool supports_iterator_range_check
Condition for applying a check across a range of values.
Definition: FreeCheckers.hpp:360