the test harness's device: the bus device plus its command line parser, and the streaming engine its tests run under - its own group_t slot, or the app's consumer group on its clock divider More...

#include <dx_test_device.h>

Inheritance diagram for dx::test::device< super_device_t, _engine_t >:

Collaboration diagram for dx::test::device< super_device_t, _engine_t >:

Classes
struct	has_license
struct	has_license< type_t, decltype((void) type_t::license, void())>
struct	mask
struct	sine

Public Types
typedef std::deque< std::string >	args
typedef _engine_t	engine_t

Public Member Functions
void	conclude () noexcept override
	the pins go while their device still stands: their streams reach its pipe on the way out
template<typename ... initializer_t>
	device (decltype(super::driver)&driver, const decltype(super::id)&id, initializer_t... initializer)
void	halt () noexcept
void	launch () override
	the audio pins go into their group, which from then on is this device's streaming engine
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	operator<< (args &args) try
virtual void	operator<< (const args &args)
virtual void	quiet (const args &={}) noexcept
void	run ()
	starting/stopping the engine's pins is what starts/stops their group's streaming session

Public Attributes
uint32_t	dropout = 0
engine_t *	engine {}
	this device's streaming engine, the harness's tests run under
uint64_t	tick = 0

Protected Types
typedef engine_t::io_t	io_t

Protected Member Functions
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_clocksource (const args &args={}) try
void	_generator (args &args) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_info (const args &) try
	list device information
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_iosize (const args &args) try
	set/get I/O streaming block size
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_license (const args &args) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_monitor (const args &args) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_reset (const args &={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_safety_offset (args &args, stream::role::role choice_role) try
	set/get the streaming group's safety offset of its transport (default: the lead the tick keeps to the device, kept per wait strategy) or of its clients (the ring margin), in clock ticks, per direction
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_samplerate (const args &args={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_source (const args &args={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_strategy (args &args) try
	set/get the wait strategies of the streaming group's transport and clients, both unless one is named
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_streaming_reset (const args &={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_string (const args &args={}) try
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	_sync_reference (const args &args) try
	set/get I/O streaming block size
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
	catch (...)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN	catch (const dx::exception &__dx_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
	catch (const std::exception &__std_exception)
DX_PRAGMA_IGNORE_RETURN_VALUE_END void	clock_monitor (std::chrono::high_resolution_clock::duration duration) try
virtual bool	head () const noexcept
virtual void	help (args &args) try
virtual void	help_head () const noexcept
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	indent (args &args) try
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	no_args (const args &args) try
void	notify () noexcept
void	process (int64_t) noexcept
DX_PRAGMA_IGNORE_RETURN_VALUE_END auto	select (const std::string &id) try
void	sweep_write (stream::direction::direction direction, uint32_t value)
	writes the swept value to the engine's client safety_offset, or - if sweep_transport - the streaming group's transport lead
virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void	version (const args &args={}) try

Protected Attributes
std::optional< engine_t >	consumer
	the engine where it is not this device's group_t slot
std::map< std::deque< std::string >, dispatch >	dictionary
std::deque< sine >	generator
std::chrono::seconds	load_duration {}
std::deque< mask >	loopback
const char *	name {}
struct {
struct {
bool ignore
} error
struct {
union {
struct {
bool err:1
bool log:1
bool out:1
}
uint32_t mask
}
} log
bool quiet
}	parameter
std::deque< mask >	pattern
std::deque< std::string >	scenarios
	load: the scenarios the monitor runs its session under in turn, each for load_duration and closed by its own lead probe
uint32_t	sweep = 0
	safety_offset ratchet: current in/out offset, raised on every pattern-test dropout for whichever direction's isr overload counted it; 0: off
stream::direction::direction	sweep_direction = stream::direction::any
	sweep scope: any= both directions seeded/ratcheted, out/in= only that one, the other stays at its own current (manually set) value
bool	sweep_transport = false
	sweep target: the transport's lead (kept per wait strategy) if set, else the client's margin
struct {
double attenuation = 1.
double frequency = 440.
mask mask
}	tmp

Detailed Description

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>
class dx::test::device< super_device_t, _engine_t >

the test harness's device: the bus device plus its command line parser, and the streaming engine its tests run under - its own group_t slot, or the app's consumer group on its clock divider

Member Typedef Documentation

◆ args

typedef std::deque<std::string> dx::parser::args

inherited

◆ engine_t

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

typedef _engine_t dx::test::device< super_device_t, _engine_t >::engine_t

◆ io_t

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

typedef engine_t::io_t dx::test::device< super_device_t, _engine_t >::io_t

protected

Constructor & Destructor Documentation

◆ device()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

template<typename ... initializer_t>

dx::test::device< super_device_t, _engine_t >::device	(	decltype(super::driver)&	driver,
		const decltype(super::id)&	id,
		initializer_t...	initializer )

inline

Here is the caller graph for this function:

Member Function Documentation

◆ _clocksource()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_clocksource ( const args & args = {} )

inlineprotected

Here is the caller graph for this function:

◆ _generator()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::_generator ( args & args )

inlineprotected

Here is the caller graph for this function:

◆ _info()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_info ( const args & )

inlineprotected

list device information

Here is the caller graph for this function:

◆ _iosize()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_iosize ( const args & args )

inlineprotected

set/get I/O streaming block size

Here is the caller graph for this function:

◆ _license()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_license ( const args & args )

inlineprotected

◆ _monitor()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_monitor ( const args & args )

inlineprotected

Here is the caller graph for this function:

◆ _reset()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_reset ( const args & = {} )

inlineprotected

Here is the caller graph for this function:

◆ _safety_offset()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_safety_offset	(	args &	args,
		stream::role::role	choice_role )

inlineprotected

set/get the streaming group's safety offset of its transport (default: the lead the tick keeps to the device, kept per wait strategy) or of its clients (the ring margin), in clock ticks, per direction

Here is the caller graph for this function:

◆ _samplerate()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_samplerate ( const args & args = {} )

inlineprotected

Here is the caller graph for this function:

◆ _source()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_source ( const args & args = {} )

inlineprotected

Here is the caller graph for this function:

◆ _strategy()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_strategy ( args & args )

inlineprotected

set/get the wait strategies of the streaming group's transport and clients, both unless one is named

Here is the caller graph for this function:

◆ _streaming_reset()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_streaming_reset ( const args & = {} )

inlineprotected

Here is the caller graph for this function:

◆ _string()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_string ( const args & args = {} )

inlineprotected

Here is the caller graph for this function:

◆ _sync_reference()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::_sync_reference ( const args & args )

inlineprotected

set/get I/O streaming block size

Here is the caller graph for this function:

◆ catch() [1/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [2/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [3/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [4/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [5/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [6/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [7/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [8/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [9/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [10/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [11/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [12/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [13/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [14/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [15/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( ... )

inlineprotected

◆ catch() [16/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [17/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [18/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [19/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [20/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [21/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [22/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [23/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [24/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [25/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [26/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [27/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [28/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [29/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [30/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN dx::test::device< super_device_t, _engine_t >::catch ( const dx::exception & __dx_exception )

inlineprotected

◆ catch() [31/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [32/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [33/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [34/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [35/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [36/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [37/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [38/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [39/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [40/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [41/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [42/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [43/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [44/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ catch() [45/45]

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

dx::test::device< super_device_t, _engine_t >::catch ( const std::exception & __std_exception )

inlineprotected

◆ clock_monitor()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::test::device< super_device_t, _engine_t >::clock_monitor ( std::chrono::high_resolution_clock::duration duration )

inlineprotected

< sweep: a pattern lock survived the monitor clear settle - dropouts only count while armed

< sweep: isr[tx]/isr[rx] overload snapshot at arming, to attribute the next dropout to a direction

< sweep: time of the last (re)start at the current value - never locking within a timeout escalates too (the never-lock trap: a start below the floor never arms, so the dropout ratchet alone would hang forever)

< samples per tick: the client margins' unit

the least reserve each lead kept: host out/in from their own cells (frames), local out/in from the ring distances at the pipe's fill/take (bytes -> ticks)

< load: the most each lead needed over the scenarios, by its cell

the lead each side needs: what it had, less the least it kept since the last clear, plus a tick - under whatever load the run saw

< load: the running scenario's threads

◆ conclude()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::conclude ( )

inlineoverridenoexcept

the pins go while their device still stands: their streams reach its pipe on the way out

◆ halt()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::halt ( )

inlinenoexcept

◆ head()

virtual bool dx::parser::head ( ) const

inlineprotectedvirtualnoexceptinherited

Reimplemented in dx::service::parser, and dx::test::driver< super_device_t, device_t, driver_t >.

Here is the caller graph for this function:

◆ help()

virtual void dx::parser::help ( args & args )

inlineprotectedvirtualinherited

Here is the call graph for this function:

Here is the caller graph for this function:

◆ help_head()

virtual void dx::parser::help_head ( ) const

inlineprotectedvirtualnoexceptinherited

Reimplemented in dx::select< parsers_t >, and dx::test::driver< super_device_t, device_t, driver_t >.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ indent()

virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::parser::indent ( args & args )

inlineprotectedvirtualinherited

Here is the call graph for this function:

Here is the caller graph for this function:

◆ launch()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::launch ( )

inlineoverride

the audio pins go into their group, which from then on is this device's streaming engine

◆ no_args()

virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::parser::no_args ( const args & args )

inlineprotectedvirtualinherited

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::notify ( )

inlineprotectednoexcept

◆ operator<<() [1/2]

DX_PRAGMA_IGNORE_RETURN_VALUE_BEGIN virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::parser::operator<< ( args & args )

inlinevirtualinherited

Reimplemented in dx::select< parsers_t >, and dx::test::driver< super_device_t, device_t, driver_t >.

Here is the call graph for this function:

◆ operator<<() [2/2]

virtual void dx::parser::operator<< ( const args & args )

inlinevirtualinherited

Here is the caller graph for this function:

◆ process()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::process ( int64_t )

inlineprotectednoexcept

◆ quiet()

virtual void dx::parser::quiet ( const args & = {} )

inlinevirtualnoexceptinherited

◆ run()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::run ( )

inline

starting/stopping the engine's pins is what starts/stops their group's streaming session

Here is the caller graph for this function:

◆ select()

DX_PRAGMA_IGNORE_RETURN_VALUE_END auto dx::parser::select ( const std::string & id )

inlineprotectedinherited

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sweep_write()

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

void dx::test::device< super_device_t, _engine_t >::sweep_write	(	stream::direction::direction	direction,
		uint32_t	value )

inlineprotected

writes the swept value to the engine's client safety_offset, or - if sweep_transport - the streaming group's transport lead

◆ version()

virtual DX_PRAGMA_IGNORE_RETURN_VALUE_END void dx::parser::version ( const args & args = {} )

inlineprotectedvirtualinherited

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ attenuation

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

double dx::test::device< super_device_t, _engine_t >::attenuation = 1.

◆ consumer

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::optional<engine_t> dx::test::device< super_device_t, _engine_t >::consumer

protected

the engine where it is not this device's group_t slot

◆ dictionary

std::map<std::deque<std::string>, dispatch> dx::parser::dictionary

protectedinherited

Initial value:

{
        {{"--continue", "--no-error", "--ignore", "--ignore-error"},
                                {[this](args& args){parameter.error.ignore= true; no_args(args);}, "ignore errors and continue"}},
        {{"--indent", "--tab"},     {std::bind(&parser::indent, this, std::placeholders::_1), "set/get indention width and pattern", "[width [pattern]]", {},{
            {{"err", "stderr"},     {[this](args&){this->parameter.log.err= true;}, "select std error"}},
            {{"log", "stdlog"},     {[this](args&){this->parameter.log.log= true;}, "select std log"}},
            {{"out", "stdout"},     {[this](args&){this->parameter.log.out= true;}, "select std out"}},
        }}},
        {{"--quiet", "-q"},     {std::bind(&parser::quiet, this, std::placeholders::_1), "quiet!"}},
 
 
 
        {{"--version", "-v"},   {std::bind(&parser::version, this, std::placeholders::_1), std::string{"display "}+ name+ " version"}},
    }

◆ dropout

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

uint32_t dx::test::device< super_device_t, _engine_t >::dropout = 0

◆ engine

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

engine_t* dx::test::device< super_device_t, _engine_t >::engine {}

this device's streaming engine, the harness's tests run under

◆ err

bool dx::parser::err

inherited

◆ [struct]

struct { ... } dx::parser::error

◆ frequency

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

double dx::test::device< super_device_t, _engine_t >::frequency = 440.

◆ generator

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::deque<sine> dx::test::device< super_device_t, _engine_t >::generator

protected

◆ ignore

bool dx::parser::ignore

inherited

◆ load_duration

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::chrono::seconds dx::test::device< super_device_t, _engine_t >::load_duration {}

protected

◆ [struct] [1/2]

struct { ... } dx::parser::log

◆ log [2/2]

bool dx::parser::log

inherited

◆ loopback

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::deque<mask> dx::test::device< super_device_t, _engine_t >::loopback

protected

◆ mask

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

mask dx::test::device< super_device_t, _engine_t >::mask

◆ name

const char* dx::parser::name {}

protectedinherited

◆ out

bool dx::parser::out

inherited

◆ [struct]

struct { ... } dx::parser::parameter

◆ pattern

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::deque<mask> dx::test::device< super_device_t, _engine_t >::pattern

protected

◆ quiet

bool dx::parser::quiet

inherited

◆ scenarios

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

std::deque<std::string> dx::test::device< super_device_t, _engine_t >::scenarios

protected

load: the scenarios the monitor runs its session under in turn, each for load_duration and closed by its own lead probe

◆ sweep

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

uint32_t dx::test::device< super_device_t, _engine_t >::sweep = 0

protected

safety_offset ratchet: current in/out offset, raised on every pattern-test dropout for whichever direction's isr overload counted it; 0: off

◆ sweep_direction

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

stream::direction::direction dx::test::device< super_device_t, _engine_t >::sweep_direction = stream::direction::any

protected

sweep scope: any= both directions seeded/ratcheted, out/in= only that one, the other stays at its own current (manually set) value

◆ sweep_transport

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

bool dx::test::device< super_device_t, _engine_t >::sweep_transport = false

protected

sweep target: the transport's lead (kept per wait strategy) if set, else the client's margin

◆ tick

template<typename super_device_t, typename _engine_t = typename super_device_t::group_t>

uint64_t dx::test::device< super_device_t, _engine_t >::tick = 0

◆ [struct]

struct { ... } dx::test::device< super_device_t, _engine_t >::tmp

The documentation for this class was generated from the following file:

dx_test_device.h

Classes

Public Types

Public Member Functions

Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ args

◆ engine_t

◆ io_t

Constructor & Destructor Documentation

◆ device()

Member Function Documentation

◆ _clocksource()

◆ _generator()

◆ _info()

◆ _iosize()

◆ _license()

◆ _monitor()

◆ _reset()

◆ _safety_offset()

◆ _samplerate()

◆ _source()

◆ _strategy()

◆ _streaming_reset()

◆ _string()

◆ _sync_reference()

◆ catch() [1/45]

◆ catch() [2/45]

◆ catch() [3/45]

◆ catch() [4/45]

◆ catch() [5/45]

◆ catch() [6/45]

◆ catch() [7/45]

◆ catch() [8/45]

◆ catch() [9/45]

◆ catch() [10/45]

◆ catch() [11/45]

◆ catch() [12/45]

◆ catch() [13/45]

◆ catch() [14/45]

◆ catch() [15/45]

◆ catch() [16/45]

◆ catch() [17/45]

◆ catch() [18/45]

◆ catch() [19/45]

◆ catch() [20/45]

◆ catch() [21/45]

◆ catch() [22/45]

◆ catch() [23/45]

◆ catch() [24/45]

◆ catch() [25/45]

◆ catch() [26/45]

◆ catch() [27/45]

◆ catch() [28/45]

◆ catch() [29/45]

◆ catch() [30/45]

◆ catch() [31/45]

◆ catch() [32/45]

◆ catch() [33/45]

◆ catch() [34/45]

◆ catch() [35/45]

◆ catch() [36/45]

◆ catch() [37/45]

◆ catch() [38/45]

◆ catch() [39/45]

◆ catch() [40/45]

◆ catch() [41/45]

◆ catch() [42/45]

◆ catch() [43/45]

◆ catch() [44/45]

◆ catch() [45/45]

◆ clock_monitor()

◆ conclude()

◆ halt()

◆ head()

◆ help()

◆ help_head()