Namespaces
	pf

Classes
struct	as

class	ChunkGenerator

class	FilterGenerator

class	FixedValuesGenerator

class	Generators

class	GeneratorUntypedBase

class	GeneratorWrapper

struct	IGenerator

class	IteratorGenerator

class	MapGenerator

class	RandomFloatingGenerator

class	RandomIntegerGenerator

class	RangeGenerator

class	RepeatGenerator

class	SingleValueGenerator

class	TakeGenerator

Typedefs
using	GeneratorBasePtr = std::unique_ptr< GeneratorUntypedBase >

Functions
template<typename T >
GeneratorWrapper< T >	value (T &&value)

template<typename T >
GeneratorWrapper< T >	values (std::initializer_list< T > values)

template<typename... Ts>
GeneratorWrapper< std::tuple< Ts... > >	table (std::initializer_list< std::tuple< typename std::decay< Ts >::type... >> tuples)

template<typename T , typename... Gs>
auto	makeGenerators (GeneratorWrapper< T > &&generator, Gs &&... moreGenerators) -> Generators< T >

template<typename T >
auto	makeGenerators (GeneratorWrapper< T > &&generator) -> Generators< T >

template<typename T , typename... Gs>
auto	makeGenerators (T &&val, Gs &&... moreGenerators) -> Generators< T >

template<typename T , typename U , typename... Gs>
auto	makeGenerators (as< T >, U &&val, Gs &&... moreGenerators) -> Generators< T >

auto	acquireGeneratorTracker (StringRef generatorName, SourceLineInfo const &lineInfo) -> IGeneratorTracker &

template<typename L >
auto	generate (StringRef generatorName, SourceLineInfo const &lineInfo, L const &generatorExpression) -> decltype(std::declval< decltype(generatorExpression())>().get())

template<typename T >
GeneratorWrapper< T >	take (size_t target, GeneratorWrapper< T > &&generator)

template<typename T , typename Predicate >
GeneratorWrapper< T >	filter (Predicate &&pred, GeneratorWrapper< T > &&generator)

template<typename T >
GeneratorWrapper< T >	repeat (size_t repeats, GeneratorWrapper< T > &&generator)

template<typename Func , typename U , typename T = FunctionReturnType<Func, U>>
GeneratorWrapper< T >	map (Func &&function, GeneratorWrapper< U > &&generator)

template<typename T >
GeneratorWrapper< std::vector< T > >	chunk (size_t size, GeneratorWrapper< T > &&generator)

template<typename T >
std::enable_if< std::is_integral< T >::value &&!std::is_same< T, bool >::value, GeneratorWrapper< T > >::type	random (T a, T b)

template<typename T >
std::enable_if< std::is_floating_point< T >::value, GeneratorWrapper< T > >::type	random (T a, T b)

template<typename T >
GeneratorWrapper< T >	range (T const &start, T const &end, T const &step)

template<typename T >
GeneratorWrapper< T >	range (T const &start, T const &end)

template<typename InputIterator , typename InputSentinel , typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
GeneratorWrapper< ResultType >	from_range (InputIterator from, InputSentinel to)

template<typename Container , typename ResultType = typename Container::value_type>
GeneratorWrapper< ResultType >	from_range (Container const &cnt)

Typedef Documentation

◆ GeneratorBasePtr

using Catch::Generators::GeneratorBasePtr = typedef std::unique_ptr<GeneratorUntypedBase>

Function Documentation

◆ acquireGeneratorTracker()

auto Catch::Generators::acquireGeneratorTracker	(	StringRef	generatorName,
		SourceLineInfo const &	lineInfo
	)		-> IGeneratorTracker &

Here is the caller graph for this function:

◆ chunk()

template<typename T >

GeneratorWrapper<std::vector<T> > Catch::Generators::chunk	(	size_t	size,
		GeneratorWrapper< T > &&	generator
	)

Here is the caller graph for this function:

◆ filter()

template<typename T , typename Predicate >

GeneratorWrapper<T> Catch::Generators::filter	(	Predicate &&	pred,
		GeneratorWrapper< T > &&	generator
	)

Here is the call graph for this function:

◆ from_range() [1/2]

template<typename Container , typename ResultType = typename Container::value_type>

GeneratorWrapper<ResultType> Catch::Generators::from_range ( Container const & cnt )

Here is the call graph for this function:

◆ from_range() [2/2]

template<typename InputIterator , typename InputSentinel , typename ResultType = typename std::iterator_traits<InputIterator>::value_type>

GeneratorWrapper<ResultType> Catch::Generators::from_range	(	InputIterator	from,
		InputSentinel	to
	)

Here is the call graph for this function:

◆ generate()

template<typename L >

auto Catch::Generators::generate	(	StringRef	generatorName,
		SourceLineInfo const &	lineInfo,
		L const &	generatorExpression
	)		-> decltype(std::declval<decltype(generatorExpression())>().get())