Test List

Class AbstractTangible_test

cover the basic operations of any tangible UI element, with the help of a mock UI element.

Member AbstractTangible_test::markState ()

mark interface state.

Member AbstractTangible_test::mutate ()

mutate the mock element through diff messages This test performs the basic mechanism used to populate the UI or to change structure or settings within individual elements.

Member AbstractTangible_test::notify ()

receive various kinds of notifications.

Member AbstractTangible_test::revealer ()

configure a handler for the (optional) "reveal yourself" functionality.

Member AbstractTangible_test::verify_mockManipulation ()

verify the UI widget unit test support framework.

Class AccessCasted_test

verify a helper template for accessing values either through conversion or (dynamic) downcast.

Class ActivityDetector_test

verify instrumentation setup to watch scheduler Activities.

Member ActivityDetector_test::insert_ActivationTap ()

inject (prepend) an ActivationTap into existing wiring

Member ActivityDetector_test::simpleUsage ()

demonstrate a simple usage scenario of this test support facility

Member ActivityDetector_test::verifyFakeExeContext ()

faked execution context to perform Activity activation

• wired internally to report each invocation into the EventLog
• by default response of post and tick is PASS, but can be reconfigured
• invocation sequence can be verified by matching internally logged events

Member ActivityDetector_test::verifyFakeInvocation ()

verify a variation of the instrumented functor to call into a custom provided fake implementation.

Member ActivityDetector_test::verifyMockInvocation ()

verify the setup and detection of instrumented invocations

• a sequence number is embedded into the ActivityDetector
• this sequence number is recorded into an attribute at each invocation
• a DSL for verification is provided (based on the EventLog)
• arguments and sequence numbers can be explicitly checked

Member ActivityDetector_test::verifyMockJobFunctor ()

diagnostic setup to detect a JobFunctor activation

• the ActivityDetector provides specifically rigged JobFunctor instances
• these capture all invocations, based on generic invocation logging
• special match qualifier to verify the job's nominal invocation time parameter
• event verification can be combined with other verifications to cover complex invocation sequences

Member ActivityDetector_test::watch_ActivationProbe ()

a rigged diagnostic probe to detect Activity activation

Member ActivityDetector_test::watch_ActivationTap ()

diagnostic adaptor to detect and pass-through Activity activation

Member ActivityDetector_test::watch_gate ()

diagnostic setup to watch Activity::GATE activation

• when applied, Tap will be inserted before and after the instrumented GATE-Activity
• it can thus be traced when the Gate is activated, but also when the Gate condition is met and the next Activity after the Gate is activated
• for this unit-test, a Gate and a follow-up Activity is invoked directly, to verify the generated log entries

Member ActivityDetector_test::watch_notification ()

diagnostic setup to detect and watch passing a notification

• setup a chain-Activity (here: a TICK) protected by a GATE
• configure the GATE to require one notification
• connect a NOTIFY-Activity to trigger the GATE
• inject a diagnostics Tap into the notification-connection
• dispatch of the notification can be verified
• notification has been passed through the Tap to the GATE
• GATE has been decremented to zero and triggers chain
• finally the chained TICK-Activity calls into the executionCtx

Class AddClip_test

adding an test clip to the Model/Session.

Class AdviceBasics_test

proof-of-concept for the Advice collaboration.

Member AdviceBasics_test::createCollaboration ()

multiple ways how to initiate the advice collaboration

Member AdviceBasics_test::overwriting_and_retracting ()

changing the provided advice, finally retracting it, causing fallback on the default value.

Member AdviceBasics_test::simpleExchange ()

the very basic usage situation: the advisor sets an information value and the advised entity picks it up.

Class AdviceBindingPattern_test

the pattern matching machinery used to find an Advice solution.

Member AdviceBindingPattern_test::verifyDynamicMatch ()

match against patterns containing variables, verify the created solution arguments

Class AdviceConfiguration_test

this is a collection of tests to cover the configuration options available as policy arguments when establishing the collaboration.

Member AdviceConfiguration_test::blockOnAdvice ()

instead of allowing default advice values, both sides may enter a blocking wait until an advice solution is available.

Member AdviceConfiguration_test::checkDefaultAdvice ()

typically, advice is a default constructible value, so there is a natural fallback in case no active advice provision exists.

Member AdviceConfiguration_test::checkSignals ()

when opening the advice collaboration, both sides may independently install a signal (callback functor) to be invoked when the actual advice solution gets established.

Class AdviceIndex_test

the Advice system uses an index datastructure to support matching the bindings to get pairs of participants to connect by an individual advice channel.

Class AdviceMultiplicity_test

stress test for the Advice system: Concurrently add a multitude of advice provisions and check correct matching and dispatch of all advice.

Member AdviceMultiplicity_test::check_highLoadSimpleMatch ()

run simple pairs of collaborators in multiple threads.

Member AdviceMultiplicity_test::check_multipleMatch ()

here, one advice might reach multiple advised entities and one entity may receive multiple pieces of advice, overwriting previous advice provisions.

Member AdviceMultiplicity_test::check_unlockedDispatch ()

when dispatching Advice, some of the locking can be left out.

Class AdviceSituations_test

documentation of the fundamental usage scenarios envisioned in the Advice concept.

Member AdviceSituations_test::pattern01_justPickAndBeHappy ()

usage pattern 01: simply consume Advice – irrespective if set explicitly.

Member AdviceSituations_test::pattern02_pickIfPresent ()

usage pattern 01: detect if specific advice was given.

Member AdviceSituations_test::pattern03_installOnlyOnce ()

usage pattern 01: .

Class AllocationCluster_test

verify the proper workings of our custom allocation scheme managing families of interconnected objects for the segments of the low-level model.

Member Appconfig_test::fetchSetupValue ()

accessing a value from setup.ini

Class ArgumentTupleAccept_test

Build a test object, which accepts a bind(...) call with specifically typed arguments.

Class AssetCategory_test

checking the properties of Asset Category structs.

Class BasicPipe_test

basic properties of Pipe (structural) Assets.

Class BlockFlow_test

document the memory management scheme used by the Scheduler.

Member BlockFlow_test::adjustEpochs ()

load based regulation of Epoch spacing

• on overflow, capacity is boosted by a fixed factor
• on clean-up, a moving average of (in hindsight) optimal length is computed and used as the new Epoch spacing

Member BlockFlow_test::announceLoad ()

announce additional load to reserve additional capacity up-front.

Member BlockFlow_test::handleEpoch ()

cover properties and handling of Epochs (low-level)

• demonstrate that each Epoch is placed into an Extent
• verify that both Extent and Epoch access the same memory block
• demonstrate the standard setup and initialisation of an Epoch
• allocate some Activities into the storage and observe free-managment
• detect when the Epoch is filled up
• verify alive / dead decision relative to given deadline

Member BlockFlow_test::placeActivity ()

place Activity record into storage

• new Activity without any previously established Epoch
• place Activity into future, expanding the Epoch grid
• locate Activity relative to established Epoch grid
• fill up existing Epoch, causing overflow to next one
• exhaust multiple adjacent Epochs, overflowing to first free one
• exhaust last Epoch, causing setup of new Epoch, with reduced spacing
• use this reduced spacing also for subsequently created Epochs
• clean up obsoleted Epochs, based on given deadline

Member BlockFlow_test::simpleUsage ()

demonstrate a simple usage scenario

• open new Epoch to allocate an Activity
• clean-up at a future time point

Member BlockFlow_test::storageFlow ()

investigate progression of epochs under realistic load

• expose the allocator to a load of 200fps for simulated 3 Minutes
• assuming 10 Activities per frame, this means a throughput of 360000 Activities
• run this load exposure under saturation for performance measurement
• use a planning to deadline delay of 500ms, but with ±200ms random spread
• after 250ms (500 steps), »invoke« by accessing and adding the random checksum
• run a comparison of all-pre-allocated ⟷ heap allocated ⟷ Refcount ⟷ BlockFlow

Class BufferMetadata_test

verify the properties of the BufferMetadata records used internally within BufferProvider to attach additional organisational data to the exposed buffers.

Member BufferMetadata_test::verifyStandardCase ()

simulate a standard buffer provider usage cycle

Class BufferMetadataKey_test

verify calculation and relations of Buffer metadata type keys.

Class BufferProviderProtocol_test

verify and demonstrate the usage cycle of data buffers for the engine based on the BufferProvider interface.

Class BuffTable_test

create a random pattern of recursive invocations, each allocating a chunk out of a global buffer table storage.

Class BuilderQualifierSupport_test

Demonstrate a technique to supply additional descriptive ctor arguments in a type safe way.

Class BuilderTool_test

the generic visitor pattern specialised for treating MObjects in the builder.

Class BuildSegment_test

the builder core functionality: create a render pipeline for a given segment of the Session/Timeline.

Class BusTerm_test

cover the standard node element (terminal element) within the UI-Bus, with the help of an attached mock UI element.

Member BusTerm_test::attachNewBusTerm ()

build a new BusTerm and verify connectivity.

Member BusTerm_test::captureStateMark ()

collect state mark notifications from bus We use a test version of the PresentationStateManager, based on the same building blocks as the real thing

Member BusTerm_test::clearStates ()

broadcast various degrees of state reset

Member BusTerm_test::commandInvocation ()

perform the full command binding and invocation protocol

Member BusTerm_test::pushDiff ()

integration test of mutation by diff message.

Member BusTerm_test::replayStateMark ()

replay previously captured state information" </dd> <dt>\anchor _test000570 \_setscope stage::model::test::BusTerm_test Member \_internalref classstage_1_1model_1_1test_1_1BusTerm__test#a08cfefabd0d8b4a7802f4a3f53968dff "BusTerm_test::verifyNotifications" ()</dt><dd> send notifications to a distinct element, or as broadcast.</dd> <dt>\anchor _test000125 \_setscope steam::engine::test::CalcStream_test Class \_internalref classsteam_1_1engine_1_1test_1_1CalcStream__test "CalcStream_test" detailed coverage of the various CalcStream flavours supported by the render engine interface.

Class CallQueue_test

verify a helper component for dispatching functors through a threadsafe queue.

Member CallQueue_test::verify_Consistency ()

consistency of queue data handling

• functors of various types can be mixed
• entries are moved in and out of the queue
• no copying whatsoever happens
• each entry gets invoked
• all entries are invoked in order
• enqueuing and dequeuing can be interspersed
• no memory leaks in bound argument data

Member CallQueue_test::verify_ThreadSafety ()

torture the CallQueue by massively multithreaded dispatch

• start #NUM_OF_THREADS (e.g.

Class CanvasHook_test

verify the mechanism to attach widgets to a canvas, while keeping the canvas implementation itself opaque.

Member CanvasHook_test::attach2canvas ()

attach several widgets with distinct coordinates and verify automated detaching on destruction.

Member CanvasHook_test::relocateWidget ()

hook a widget at a specific position and then later relocate it on the canvas through the ViewHook front-end.

Class CmdContext_test

verify the front-end for context bound commands, command argument binding and invocation state from within the UI structures.

Class CmdlineWrapper_test

for lib::Cmdline, wrapping various example cmdlines

Member CmdlineWrapper_test::testStandardCmdlineformat ()

wrapping a (albeit faked) standard commandline given as (argc, argv[])

Class CommandArgument_test

Check storage handling of the command parameters and state memento.

Member CommandArgument_test::createTuples (ArgTuples &tup)

create various argument tuples and re-access their contents

Member CommandArgument_test::serialiseArgTuples (ArgTuples &tup)

serialise and de-serialise each tuple and check validity

Member CommandArgument_test::simulateCmdLifecycle ()

simulate a complete command lifecycle with regards to the storage handling of the command parameters and state memento.

Class CommandBasic_test

basic usage of the Steam-Layer command dispatch system.

Class CommandBinding_test

coverage for some specific situations when binding command arguments.

Class CommandCloneBuilder_test

check creation of a command implementation clone from top level, without disclosing specific type information about the involved closure.

Member CommandCloneBuilder_test::verifySeparation (PCmdImpl orig, PCmdImpl copy)

verify the two command implementation frames are indeed separate objects without interconnection.

Class CommandEquality_test

cover command equality detection.

Class CommandInstanceManager_test

CommandInstanceManager is responsible for providing individual clone copies from a basic command definition, to be bound with actual arguments and finally handed over to the SteamDispatcher for invocation.

Member CommandInstanceManager_test::verify_duplicates ()

there can be only one active "opened" instance The CommandInstanceManager opens (creates) a new instance by cloning from the prototype.

Member CommandInstanceManager_test::verify_extendedUsage ()

demonstrate the complete command instance usage pattern.

Member CommandInstanceManager_test::verify_fallback ()

the instance manager automatically falls back on globally registered commands, when the given ID is not and was not known locally

Member CommandInstanceManager_test::verify_instanceIdentity ()

relation of command, instanceID and concrete instance The CommandInstanceManager provides the notion of a current instance, which can then be used to bind arguments.

Member CommandInstanceManager_test::verify_lifecycle ()

verify sane command lifecycle is enforced

• instance need to be opened (created) prior to access
• can not dispatch an instance not yet created
• can not create new instance before dispatching the existing one
• can not dispatch an instance before binding its arguments
• can not access an instance already dispatched

Member CommandInstanceManager_test::verify_simpleUsage ()

demonstrate the transparent instance generation (»fire and forget«)

• when just specifying a global commandID and arguments, an anonymous instance will be created on-the-fly, bound and dispatched, without leaving any traces in the global or local registry
• when dispatching a global commandID, where the corresponding prototype entry is already fully bound and ready for execution, likewise an anonymous clone copy is created and dispatched.

Class CommandMessageBinding_test

verify the simple standard usage pattern, where command arguments for binding are passed via UI-Bus message with GenNode elements.

Member CommandMutation_test::checkMutation ()

check the Mutation functor which is bound to our testFunc(int).

Member CommandMutation_test::checkStateCapturingMechanism ()

check the undo memento capturing mechanism in isolation

Member CommandMutation_test::checkUndoMutation ()

check the special Mutation which is used to undo a command.

Class CommandQueue_test

verify proper working of queue management used within SteamDispatcher.

Class CommandRegistry_test

verify sane behaviour of the relevant operations on the CommandRegistry interface.

Member CommandRegistry_test::checkAllocation (CommandRegistry &registry)

verify the allocation/de-allocation handling as embedded into the CommandRegistry operation.

Member CommandRegistry_test::checkRegistration (CommandRegistry &registry)

verify the index operation.

Class CommandSetup_test

cover the behaviour of the CommandSetup helper intended for inserting actual command definitions into the Session.

Member CommandSetup_test::verify_DefinitionRegistration ()

actually issue the definitions captured as side-effect of the preceding test.

Member CommandSetup_test::verify_DefinitionSetup ()

create some command definitions inline and verify their properties.

Member CommandSetup_test::verify_standardUsage ()

demonstrate the standard usage pattern of command definition setup

• static CommandSetup instances are created "somewhere"
• when the ON_GLOBAL_INIT lifecycle event is issued, all command definitions collected thus far are invoked and thus inserted into the steam::control::CommandRegistry
• from this point on, we may access a control::Command handle corresponding to these definitions, and we may create derived instances to bind parameters and invoke the operation.

Class CommandUse1_test

command usage aspects I: defining commands in various ways, then re-accessing those definitions, create instances, invoke them and undo the effect.

Class CommandUse2_test

command usage aspects II: patterns of command invocation.

Member CommandUse2_test::check_DispatcherInvocation ()

simplified integration test of command dispatch

• performs the minimal actions necessary to start the session loop thread
• then issues a test command, which will be queued and dispatched by the SteamDispatcher.

Class CommandUse3_test

command usage aspects III: elaborate handling patterns, like e.g.

Member CompoundMedia_test::buildCompound ()

building a compound media asset by using a special factory, normally intended for loading existing sessions.

Member CompoundMedia_test::modifyCompound ()

adding and removing elementary media.

Member CompoundMedia_test::verifyClipStructure ()

create a (compound) clip from some compound media asset and verify the clip mirrors the media asset's structure

Class ConfigFlags_test

check the handling of types representing a specific configuration.

Member ConfigFlags_test::check_ConfigSelector ()

use the ConfigSelector template to build a set of factories, based on a set of configurations.

Member ConfigFlags_test::check_filter ()

given a list of flag-tuples, we first create config-types out of them and then filter out those configs for which template Maybe is defined

Member ConfigFlags_test::check_FlagInfo ()

FlagInfo metafunction, which takes as argument a list-of-flags as well as a list-of-lists-of-flags and especially allows to apply a visitor object to the latter

Member ConfigFlags_test::check_flags ()

conversion between list-of-flags and a config-type in both directions

Member ConfigFlags_test::check_instantiation ()

creates a predicate template (metafunction) returning true iff the template Maybe is defined for the configuration in question

Class CreateAsset_test

creating new Assets and registering them with the AssetManager.

Member CreateAsset_test::createMedia ()

Creating and automatically registering Asset instances.

Member CreateAsset_test::factoryVariants ()

different variants of calling the MediaFactory, with focus on the behaviour of the basic Asset creation machinery.

Class CustomSharedPtr_test

assure correct behaviour of lumiera's custom shared-ptr, including ADL of operators, shared ownership, typing and ordering

Member CustomSharedPtr_test::check_ordering ()

equality and ordering operators forwarded to pointee

Member CustomSharedPtr_test::check_refcounting ()

smart-ptr basic behaviour

Member CustomSharedPtr_test::check_shared_ownership ()

cooperation with other shared-ptr types

Member CustomSharedPtr_test::check_type_relations ()

building type relationships on smart-ptrs

Class DataCSV_test

Document and verify a data table component to maintain measurement data series, backed by CSV storage.

Member DataCSV_test::demonnstrate_CSV_Notation ()

simplified notation of inline CSV data for tests

Member DataCSV_test::simpleUsage ()

add rows and data to a table without filename.

Member DataCSV_test::verify_CSV_Format ()

validate the simple CSV conversion functions used by DataTable

Member DataCSV_test::verify_persistentDataFile ()

verify a table backed by persistent CSV data

Class DefsManager_test

basic behaviour of the defaults manager ("the big picture")

• retrieving a "default" object repeatedly
• retrieving a more constrained "default" object
• failure registers a new "default"
• instance management

Class DefsManagerImpl_test

verify some general assumptions regarding implementation details of the the defaults manager.

Class DefsRegistryImpl_test

build an registry table (just for this test) configured for some artificial test Types.

Class DeleteAsset_test

deleting an Asset includes removing all dependent Assets and all MObjects relying on these.

Class DeleteClip_test

removing a test clip from the Session/Model.

Class DelStash_test

create a bunch of objects with varying type and size, memorising how to kill them properly.

Member DelStash_test::checkCustomKill ()

use a custom-provided deleter function

Class DependencyConfiguration_test

verify the various modes of creating dependencies.

Member DependencyConfiguration_test::verify_automaticReplacement ()

injecting test mocks temporarily

Member DependencyConfiguration_test::verify_customFactory ()

instance creation can be preconfigured with a closure.

Member DependencyConfiguration_test::verify_expose_Service_with_Lifecycle ()

expose a dedicated service instance, which can be shut down

Member DependencyConfiguration_test::verify_Singleton ()

without special configuration, singletons are injected as dependency

Member DependencyConfiguration_test::verify_SubclassSingleton ()

preconfigure a specific subclass to be injected as singleton dependency

Class DependencyFactory_test

verify the various modes of creating dependencies.

Class DependentAssets_test

the handling of Assets dependent on other Assets and the enabling/disabling of Assets.

Member DependentAssets_test::checkDependencyMechanics ()

check operation of basic asset dependency support

Member DependentAssets_test::checkEnablementPropagation ()

enabling and disabling an asset should propagate to dependant assets

Member DependentAssets_test::checkRealAssetDependencyRegistration ()

each real world asset subclass has to care for registering and deregistering any additional dependencies.

Member DependentAssets_test::checkUnlinking ()

unlink operation removing inter asset links

Class DiagnosticContext_test

verify a diagnostic facility to collect and access contextual information.

Member DiagnosticContext_test::verify_heavilyParallelUsage ()

verify the thread local property of ContextStack.

Member DiagnosticContext_test::verify_simpleAccess ()

create nested scopes and place a DiagnosticContext frame into each.

Class DiffComplexApplication_test

Demonstration: apply a structural change to unspecified private data structures, with the help of an dynamic adapter

• we use private data classes, defined right here in the test fixture to represent "just some" pre-existing data structure.

Class DiffIgnoreChanges_test

Special case: build a TreeMutator to accept any change and do nothing.

Member DiffIgnoreChanges_test::fail_or_ignore ()

fail or ignore, depending on toggle.

Member DiffIgnoreChanges_test::fish_for_content ()

fish some content and ignore everything else.

Class DiffIndexTable_test

Cover a simple lookup table helper, used to support diff generation.

Class DiffListApplication_test

Demonstration/Concept: a description language for list differences.

Class DiffListGeneration_test

Demonstration/Concept: how to derive a list diff representation from the comparison of two sequences.

Class DiffTreeApplication_test

Demonstration/Concept: a description language for tree differences.

Class DiffTreeApplicationSimple_test

Demonstration/Concept: apply a "tree diff" to reshape structured data.

Member DiffTreeApplicationSimple_test::demo_one ()

mutate a Record<GenNode> by applying the sample diff

Member DiffTreeApplicationSimple_test::demo_two ()

mutate a STL collection opaquely by applying the sample diff

Class DiffTreeMutationListener_test

When creating a TreeMutator binding, a listener (lambda) can be attached, to be invoked on structural changes...

Class Digxel_test

verify correct behaviour of an display "Digxel": A self-contained numeric element to support building displays.

Member Digxel_test::checkDisplayOverrun ()

Digxel should be protected against display buffer overrun

Member Digxel_test::timingMeasurements ()

perform several timing measurements and especially verify the effect of caching formatted values.

Member Digxel_test::verifyAssignMutatingOperators ()

verify the self-assigning increment/decrement operators.

Class DigxelConfigurations_test

verify correctness of the predefined standard Digxels.

Class DispatcherInterface_test

document and verify the engine::Dispatcher interface, used to translate a CalcStream into individual node jobs.

Member DispatcherInterface_test::accessJobTicket ()

the dispatcher knows how to pick the right JobTicket for each point on the timeline, and thus how to access the proper part of the render nodes responsible for rendering this part of the timeline

Member DispatcherInterface_test::pipelineBuilder ()

for the actual use case, the dispatcher acts as entrance point to a job-planning pipeline builder, which in the end is an iterator to pull render jobs from

Member DispatcherInterface_test::resolveModelPort ()

the dispatcher can resolve a known ModelPort into the internal index number used on the Segmentation for the corresponding timeline (which exposes this ModelPort)

Class DispatcherLooper_test

verify encapsulated control logic of SteamDispatcher.

Member DispatcherLooper_test::verifyBuilderStart ()

logic to trigger the builder over a complete simulated lifecycle.

Class DuckDetector_test

verify building predicates to detect properties of a type at compile time.

Class DuckDetectorExtension_test

demonstrate some details regarding detection of functions within a type.

Member DuckDetectorExtension_test::detect_freeFunctionADL_ExtensionPoint ()

detect the presence of a free function extension point at compile time.

Member DuckDetectorExtension_test::detect_memberFunctionVariations ()

cover variations of member function detection

• detect an explicitly given full signature
• detect just the presence of a function name
• distinguish this from detecting a member
• detect especially a member function without arguments

Class DummyPlayConnection_test

verify the OutputSlot interface and base implementation by performing full data exchange cycle.

Class ElementAccess_test

verify the usage pattern of low-level UI element access, based on a mock implementation of the accessor directory.

Member ElementAccess_test::verify_simpleAccess ()

simple access to an existing element designated by coordinates

Member ElementAccess_test::verify_standardUsage ()

the standard use case is to create one new child node below an existing path (widget) within the UI

Class EngineInterface_test

cover the basic service exposed at the engine interface: create a calculation stream and verify the translation into individual jobs.

Class EntryID_test

proof-of-concept test for a combined symbolic and hash based ID.

Member EntryID_test::buildHashtable ()

build a hashtable, using EntryID as key, thereby using the embedded hash-ID

Member EntryID_test::checkErasure ()

handling of EntryIDs through their common base class, which means erasing the specific type information.

Class EventLog_test

verify a logging facility, which can be used to ensure some events happened while running test code.

Member EventLog_test::verify_logJoining ()

combining several logs The EventLog objects are actually just lightweight front-end handles, while the actual log lives on the Heap.

Member ExceptionError_test::checkErrorFlagPropagation ()

verify throwing of Exceptions based on a non-cleared C error flag

Member ExceptionError_test::checkRootCauseChaining ()

the chaining of lumiera::Exception objects and the retrieval of the original root cause.

Member ExceptionError_test::doubleNestedTh (string msg)

repeated repackaging and rethrowing

Member ExceptionError_test::nestedThrower (string msg)

catching, repackaging and rethrowing of errors.

Member ExceptionError_test::throwSpecial (string)

simply throw some exception and pass context info

Class ExtentFamily_test

document and verify a memory management scheme to maintain a flexible set of »memory extents« for cyclic usage.

Member ExtentFamily_test::iteration ()

verify access to the extents by iteration, thereby possibly claiming the next extents

Member ExtentFamily_test::reuseUnclean ()

verify that neither constructors nor destructors are invoked automatically when discarding or re-using extents.

Member ExtentFamily_test::simpleUsage ()

demonstrate a simple usage scenario

Member ExtentFamily_test::use_and_drop ()

verify claiming new and discarding old slots

Member ExtentFamily_test::wrapAround ()

verify in detail how iteration wraps around to also reuse previously dropped extents, possibly rearranging the internal management-vector to allow growing new extents at the end.

Class FileSupport_test

verify supplemental helper functions for file-handling support, provided to complement the C++ <filesystem> library.

Member FileSupport_test::homedirectoryExpansion ()

verify consolidated path

• retrieves and expands the POSIX home directory
• transforms into canonical, absolute path

Class FixtureChangeDetector_test

planned test for detecting changes in a given segmentation

Class FixtureSegment_test

Verify properties and behaviour of a single Segment in the Segmentation

• construction of a mocked Segment
• on-demand allocation of a JobTicket for a ModelPort(index)

Member FixtureSegment_test::fabricate_MockSegment ()

setup a properly structured ExitNode graph using the specification scheme supported by MockSegmentation

Member FixtureSegment_test::retrieve_JobTicket ()

on-demand generate a JobTicket from an existing NodeGraphAttachment

Class FormatCOUT_test

How to build generic string conversion into ostream::operator<<.

Class FormatHelper_test

verifies the proper working of some string-formatting helper functions.

Member FormatHelper_test::check2String ()

verify a failsafe to-string conversion.

Member FormatHelper_test::checkPrefixSuffix ()

convenience helpers to deal with prefixes and suffixes

Member FormatHelper_test::checkStringify ()

inline to-string converter function

• can be used as transforming iterator
• alternatively accept arbitrary arguments

Member FormatHelper_test::checkStringJoin ()

verify delimiter separated joining of arbitrary collections.

Class FormatString_test

verifies our front-end for printf-style format string based formatting.

Class FormatSupport_test

check how support for a specific timecode format can be enabled and detected.

Class FunctionClosure_test

building a function closure for a given function or functor, while arguments are passed in as tuple

• accessing signatures as typelists
• apply free function to tuple
• apply functor to tuple
• bind free function to tuple
• bind functor to tuple
• build a simple "tuple closure"

Class FunctionComposition_test

this test covers some extensions and variations on function closures:

• partial application of a function, returning a partial closure
• variation: binding an arbitrary term, might even be a nested binder
• chaining of two functions with suitable arguments ("composition")

Member FunctionComposition_test::verify_referenceHandling ()

ensure reference types and arguments are handled properly

Class FunctionErasure_test

Create specifically typed functor objects and then wrap them into common holder objects, thereby discarding the specific signature type information.

Class FunctionSignature_test

verify metaprogramming trait to pick up function signature types.

Class GeneratorCombinations_test

check utilities for generating case combinations.

Class GenericIdFunction_test

cover a standard scheme to generate type and instance identifiers.

Class GenericRecord_test

Verify properties of a special collection type meant for external representation of object-like data, especially for symbolic representation in diff messages.

Class GenNode_test

Verify properties of a special collection type shaped for external representation of object-like data.

Member GenNode_test::convenienceRecAccess ()

simplified notation for access to nested record properties.

Class GnuplotGen_test

verify data visualisation by generated Gnuplot scripts

• generate a simple pot
• generate a scatter plot with regression line

Member GnuplotGen_test::plot_scatter_regression ()

Create a (x,y) scatter plot with regression line

• in the simple case, there is only one diagram
• use the stats command to let Gnuplot calculate the linear regression
• draw a regression line as function representing the regression model

Member GnuplotGen_test::simpeUsage ()

Create simple (x,y) data point visualisation

Member GnuplotGen_test::verify_customisation ()

various customisations through additional parameters

• a custom defined regression line
• use a specific output »term« and specify canvas size
• define the common horizontal data range and x-tic spacing
• define display ranges for 3 different Y-axis
• define custom labels for all axes

Class HandlingPatternBasics_test

operate and verify a simple dummy command handling pattern.

Member HandlingPatternBasics_test::checkExec (PCommandImpl com)

verify the Handling pattern API: execute a command

Member HandlingPatternBasics_test::checkUndo (PCommandImpl com)

verify the Handling pattern API: undo a command

Member HandlingPatternBasics_test::useCustomHandler (PCommandImpl com)

use custom implementation of the HandlingPattern interface, rigged to verify the functions are actually invoked.

Class HandlingPatternStandardImpl_test

verify correct behaviour of all the command handling patterns provided by the default configuration of a lumiera session.

Class HashGenerator_test

cover various detail aspects regarding hash value generation

• weakness of boost::hash

Member HashGenerator_test::demonstrate_boost_hash_weakness ()

demonstrate a serious weakness of boost::hash for strings.

Member HashGenerator_test::verify_Knuth_workaround ()

verify a well-known pragmatic trick to help with unevenly spaced hash values.

Class HashIndexed_test

proof-of-concept test for a generic hash based and typed ID struct.

Class HashStandardToBoostBridge_test

document and verify an automatic bridge to integrate boost-style hash functions with the new std::hash template.

Class HelloBug_test

cover known regressions

Class HelloWorld_test

demo of using the test framework

Class IdentityOfAssets_test

creating several Assets and checking object identity, detection of duplicates and version handling.

Member IdentityOfAssets_test::createDuplicate ()

produce an ID clash.

Class IncidenceCount_test

verify recording and evaluation of concurrent invocations of a piece of code instrumented for investigation.

Member IncidenceCount_test::demonstrate_usage ()

watch time spent in code bracketed by measurement calls.

Member IncidenceCount_test::perform_multithreadStressTest ()

verify thread-safe operation under pressure.

Member IncidenceCount_test::verify_concurrencyStatistic ()

verify observation of concurrency degree.

Member IncidenceCount_test::verify_incidentCount ()

verify proper counting of possibly overlapping incidences.

Class IosSavepoint_test

verifies capturing and restoring of std::ostream formatting state.

Member IosSavepoint_test::nested ()

verify usage in nested scopes

Member IosSavepoint_test::restoreAfterException ()

verify clean-up happens even in case of an exception

Member IosSavepoint_test::setFill ()

verify that a custom fill character is cleared

Member IosSavepoint_test::switchToHex ()

verify that hexadecimal output is cleared

Class ItemWrapper_test

use the ItemWrapper to define inline-storage holding values, pointers and references.

Member ItemWrapper_test::verifyFunctionRefResult ()

verify an extension built on top of the ItemWrapper: a function which remembers the last result.

Member ItemWrapper_test::verifyFunctionResult ()

verify an extension built on top of the ItemWrapper: a function which remembers the last result.

Member ItemWrapper_test::verifySaneInstanceHandling ()

verify that ctor and dtor calls are balanced, even when assigning and self-assigning.

Member ItemWrapper_test::verifySaneMoveHandling ()

proper handling of move and rvalue references

Member ItemWrapper_test::verifyWrappedRef ()

verify especially that we can wrap and handle a reference "value" in a pointer-like manner

Class IterableClassification_test

verify the (static) classification/detection of iterables.

Class IterAdapter_test

set up example implementations based on the iterator-adapter templates and verify the behaviour in accordance to the concept "lumiera forward iterator"

Member IterAdapter_test::enumerate ()

enumerate all number within a range

Member IterAdapter_test::exposeDataAddresses ()

build an iterator to expose the address of underlying data elements

Member IterAdapter_test::iterTypeVariations (TestContainer &elms)

verify the const and dereferencing variants, which can be created based on IterAdapter

Member IterAdapter_test::simpleUsage (CON &elms)

use the IterAdapter as if it was a STL iterator

Member IterAdapter_test::verifyComparisons (TestContainer &elms)

iterator comparison, predicates and operators

Member IterAdapter_test::wrapIterRange ()

usage scenario, where we allow the client to access a range of elements given by STL iterators, without any specific iteration behaviour.

Class IterAdapterSTL_test

verify some of the adapters to expose typical container usage patterns as Lumiera Forward Iterators.

Class IterChainSearch_test

verify a setup for consecutive searches with backtracking.

Member IterChainSearch_test::backtracking ()

verify a complex search with backtracking.

Member IterChainSearch_test::chainedIteration ()

verify consecutive application of several functors on the underlying filter.

Member IterChainSearch_test::simpleSearch ()

simple basic use case.

Class IterCursor_test

demonstrate and cover the properties of IterCursor.

Member IterCursor_test::iterTypeVariations ()

verify variant created from a const_iterator, based on the const-ness of the underlying STL iterator

Member IterCursor_test::simpleIteration ()

just iterate in various ways.

Member IterCursor_test::switchDirection ()

verify the ability of IterCursor to switch the direction of the iteration.

Member IterCursor_test::verifyComparisons (IT const &ii)

verify equality handling and NIL detection for the given iterator/wrapper handed in.

Class IterExplorer_test

use a simple source iterator yielding numbers to build various functional evaluation pipelines, based on the IterExplorer template.

Member IterExplorer_test::demonstrate_LayeredEvaluation ()

Demonstration how to build complex algorithms by layered tree expanding iteration

Member IterExplorer_test::verify_aggregatingGroupItration ()

another form of grouping, where groups are formed by a derived property thereby passing each element in the group to an aggregator function, working on an accumulator per group.

Member IterExplorer_test::verify_asIterSource ()

package the resulting Iterator as automatically managed, polymorphic opaque entity implementing the IterSource interface.

Member IterExplorer_test::verify_combinedExpandTransform ()

combine the recursion into children with a tail mapping operation.

Member IterExplorer_test::verify_customProcessingLayer ()

extension point to inject a client-defined custom processing layer This special builder function allows to install a template, which needs to wrap a source iterator and expose a state core like interface.

Member IterExplorer_test::verify_depthFirstExploration ()

use a preconfigured exploration scheme to expand depth-first until exhaustion.

Member IterExplorer_test::verify_effuse ()

verify terminal operation to append all results into a container.

Member IterExplorer_test::verify_elementGroupingOperation ()

package elements from the source pipeline into fixed-sized groups.

Member IterExplorer_test::verify_expand_rootCurrent ()

special feature of the Expander to lock into current child sequence.

Member IterExplorer_test::verify_expandOperation ()

use a preconfigured "expand" functor to recurse into children.

Member IterExplorer_test::verify_FilterChanges ()

a special filter layer which can be re-configured on the fly

Member IterExplorer_test::verify_FilterIterator ()

add a filtering predicate into the pipeline.

Member IterExplorer_test::verify_IterSource ()

ability to wrap and handle IterSource based iteration.

Member IterExplorer_test::verify_reduceVal ()

verify terminal operation to sum or reduce all values from the pipeline.

Member IterExplorer_test::verify_scheduledExpansion ()

child expansion can be scheduled to happen on next iteration.

Member IterExplorer_test::verify_transformOperation ()

pipe each result through a transformation function.

Member IterExplorer_test::verify_untilStopTrigger ()

control end of iteration by a stop condition predicate.

Member IterExplorer_test::verify_wrappedIterator ()

IterExplorer is able to wrap any Lumiera Forward Iterator

Member IterExplorer_test::verify_wrappedState ()

without using any extra functionality, IterExplorer just wraps an iterable state.

Class IterIndex_test

demonstrate and cover the properties of IterCursor.

Member IterIndex_test::iterTypeVariations ()

verify the const and dereferencing variants, based on the const-ness of the underlying STL iterator

Member IterIndex_test::simpleIteration ()

just iterate in various ways.

Member IterIndex_test::verify_randomAccess ()

verify the ability of IterCursor to switch the direction of the iteration.

Member IterIndex_test::verifyComparisons (IT const &ii)

verify equality handling and NIL detection for the given iterator/wrapper handed in.

Class IterQueue_test

cover an easy to use queue, built as convenience wrapper on top of std::deque and allowing element retrieval by iteration.

Class IterSource_test

create some (opaque) data sources, and then pull the data out by iteration.

Member IterSource_test::verify_singleValIter ()

an IterSouce which returns just a single value once

Member IterSource_test::verify_transformIter ()

verify transforming an embedded iterator This test not only wraps a source iterator and packages it behind the abstracting interface IterSource, but in addition also applies a function to each element yielded by the source iterator.

Class IterStack_test

cover behaviour of a convenience class built by using a std::deque as "state core" of an Lumiera IterStateWrapper.

Class IterTools_test

build combined and filtering iterators with the help of lib::IterTool.

Member IterTools_test::buildWrappedSingleElement ()

wrap an arbitrary single element as pseudo-iterator

Member IterTools_test::verify_filterExtension ()

verify the ability to extend a filter condition while in the middle of an ongoing iteration.

Member IterTools_test::verify_filterRepetitions ()

verify the helper to filter duplicate elements emitted by an source iterator.

Member IterTools_test::verifyComparisons (IT const &ii)

verify equality handling and NIL detection for the given iterator/wrapper handed in

Class JobHash_test

verify the basic properties of the job and job descriptor struct; especially verify that job data is passed properly back to the closure and that a identity can be constructed based on a hash of the job's data.

Class JobPlanning_test

document and verify the data aggregation and the calculations necessary to prepare render jobs for scheduling.

Member JobPlanning_test::calculateDeadline ()

verify the timing calculations to establish the scheduling deadline of a simple render job

Member JobPlanning_test::setupDependentJob ()

verify the setup of a prerequisite job in relation to the master job depending on this prerequisite

Member JobPlanning_test::simpleUsage ()

demonstrate a simple usage scenario

Class JobPlanningPipeline_test

demonstrate interface, structure and setup of the job-planning pipeline.

Member JobPlanningPipeline_test::accessTopLevelJobTicket ()

use the base tick to access the corresponding JobTicket through the Dispatcher interface (mocked here).

Member JobPlanningPipeline_test::buildBaseTickGenerator ()

use the Dispatcher interface (mocked) to generate a frame »beat«

• demonstrate explicitly the mapping of a (frame) number sequence onto a sequence of time points with the help of time quantisation
• use the Dispatcher API to produce the same frame time sequence

Member JobPlanningPipeline_test::demonstrateScaffolding ()

document and verify the mock setup used for this test

Member JobPlanningPipeline_test::exploreJobTickets ()

build and verify the exploration function to discover job prerequisites

• use a setup where the master ExitNode requires a prerequisite ExitNode to be pulled
• mark the pipeline-IDs, so that both nodes can be distinguished in the resulting Jobs
• the expandPrerequisites() builder function uses JobTicket::getPrerequisites()
• and this »expander« function is unfolded recursively such that first the source appears in the iterator, and as next step the child prerequisites, possibly to be unfolded further recursively
• by design of the iterator pipeline, it is always possible to access the PipeFrameTick
• this corresponds to the top-level JobTicket, which will produce the final frame
• putting all these information together, proper working can be visualised.

Member JobPlanningPipeline_test::integration ()

Job-planning pipeline integration test

• use the MockDispatcher to define a fake model setup
• define three levels of prerequisites
• also define a second segment with different structure
• build a complete Job-Planning pipeline
• define a visualisation to expose generated job parameters
• iterate the Job-Planning pipeline and apply the visualisation

Class LateBindInstance_test

verify a scheme to supply the actual instance for member function invocation.

Member LateBindInstance_test::demonstrateUsage ()

demonstrate the usage of lib::meta::lateBindInstance():

• construct an argument tuple
• mark the position of the this-ptr with a placeholder
• rewrite the arguments later when the actual instance is known
• member function can now be invoked, since the instance was injected.

Member LateBindInstance_test::verify_cornerCases ()

replacement happens uniformly on all kinds of tuples

Member LateBindInstance_test::verify_forwarding ()

verify that the rewriting process does not incur unnecessary data copies

Class LazyInit_test

Verify a mix-in to allow for lazy initialisation of complex infrastructure tied to a std::function; the intention is to have a »trap« hidden in the function itself to trigger on first use and perform the one-time initialisation, then finally lock the object at a fixed place.

Member LazyInit_test::verify_complexUsageWithCopy ()

use an elaborately constructed example to cover more corner cases

• the function to manage and initialise lazily is a member of the derived class
• the initialisation routine adapts this function and links it with the current object location; thus, invoking this function on a copy would crash / corrupt memory.

Member LazyInit_test::verify_inlineStorage ()

verify that std::function indeed stores a simple functor inline.

Member LazyInit_test::verify_lazyInitialisation ()

demonstrate a basic usage scenario

Member LazyInit_test::verify_TargetRelocation ()

verify navigating an object structure by applying known offsets consecutively from a starting point within an remote instance

Member LazyInit_test::verify_triggerMechanism ()

demonstrate the trigger mechanism in isolation

Member LazyInit_test::verify_trojanLambda ()

verify construction of the »trap« front-end eventually to trigger initialisation

• this test does not involve any std::function, rather a heap-allocated copy of a λ

the _target function_ finally to be invoked performs a verifiable computation

the _delegate_ receives an memory location and returns a reference to the target

the generated _»trojan λ«_ captures its own address, invokes the delegate,

retrieves a reference to a target functor, and finally invokes this with actual arguments.

lumiera::test::LifeCycle_test Class LifeCycle_test the global lifecycle hooks got registered, the ON_BASIC_INIT hook has been already called, while our custom callback can be triggered at our will

lib::test::LinkedElements_test Class LinkedElements_test cover our custom single linked list template, in combination with Lumiera Forward Iterators and the usage of a custom allocator.

lib::test::LinkedElements_test Member LinkedElements_test::verify_nonOwnership () add some node elements to the LinkedElements list but without taking ownership or performing any memory management.

lib::test::LinkedElements_test Member LinkedElements_test::verify_RAII_safety () to support using LinkedElements within RAII-style components, all the elements might be added in one sway, by pulling them from a Lumiera Forward Iterator.

steam::asset::test::MakeClip_test Class MakeClip_test creating a Clip MObject and an associated Clip Asset from a given asset::Media.

vault::test::MediaAccessMock_test Class MediaAccessMock_test inject a Mock object replacing the backend_interface::MediaAccessFacade.

steam::control::test::MementoTie_test Class MementoTie_test Verify the state capturing mechanism (memento), which is used to implement the Undo() functionality for Steam-Layer commands.

lib::meta::test::MetaUtils_test Class MetaUtils_test verify basic type trait and metaprogramming helpers.

lib::meta::test::MetaUtils_test Member MetaUtils_test::verify_basicTypeProbing () demonstrate the basic type trait detection technique:

• we have two overloads with differing return type
• we form a function call expression
• by investigating the return type, we can figure out which overload the compiler picks.

steam::mobject::test::MObjectInterface_test Class MObjectInterface_test cover the common behaviour of all MObjects.

steam::mobject::test::MObjectRef_test Class MObjectRef_test properties and behaviour of the external reference-mechanism for MObjects placed into the session.

steam::engine::test::MockSupport_test Class MockSupport_test validate test support for render job planning and dispatch.

steam::engine::test::MockSupport_test Member MockSupport_test::simpleUsage () simple usage example of the test helpers

steam::engine::test::MockSupport_test Member MockSupport_test::verify_MockDispatcherSetup () verify setup of a mocked Dispatcher instance

• by default, MockDispatcher generates a single segment to span the whole Time-axis and with some random yet valid pipeline-ID, so that a single job ticket can be generated for each port everywhere
• in addition, it is possible to use the same specification language as for Segmentation to define a more complex (mock)processing graph

steam::engine::test::MockSupport_test Member MockSupport_test::verify_MockJob () document and verify usage of a mock render job

steam::engine::test::MockSupport_test Member MockSupport_test::verify_MockJobTicket () document and verify usage of a mock JobTicket for frame dispatch

steam::engine::test::MockSupport_test Member MockSupport_test::verify_MockPrerequisites () build a Segment with additional prerequisites, resulting in additional JobTickets to explore and additional prerequisite Jobs to build for each frame.

steam::engine::test::MockSupport_test Member MockSupport_test::verify_MockSegmentation () document and verify usage of a complete mocked Segmentation to back frame dispatch

• default constructed: empty Segmentation
• cover the whole axis with one segment
• partition axis and verify the association of generated jobs
• a fully defined segment within an otherwise empty axis
• complex partitioning (using the »split-splice« mechanism

steam::fixture::test::ModelPortRegistry_test Class ModelPortRegistry_test create a standalone model port registry to verify the behaviour of model ports, accessed through reference handles.

lib::test::MultiFact_test Class MultiFact_test verify the basic usage patterns of the configurable factory template.

lib::test::MultiFactArgument_test Class MultiFactArgument_test define a MultiFact (factory with dynamic registration), which accepts additional arguments and passes them through to the registered factory function(s).

lib::test::MultiFactSingleton_test Class MultiFactSingleton_test verify the use of the MultiFact template to access Singletons.

lib::diff::test::MutationMessage_test Class MutationMessage_test properties of a container to transport a diff from an abstracted source generator to an abstracted consumer.

lib::diff::test::MutationMessage_test Member MutationMessage_test::demonstrate_standardUsage () demonstrate the intended usage pattern

• a diff generation context is allocated
• the MutationMessage takes ownership
• and exposes the generated diff sequence
• which is pulled during iteration

lib::diff::test::MutationMessage_test Member MutationMessage_test::demonstrate_treeApplication () use MutationMessage to transport and apply changes to target data

steam::engine::test::NodeBasic_test Class NodeBasic_test basic render node properties and behaviour.

steam::engine::test::NodeFabrication_test Class NodeFabrication_test creating and wiring various kinds of render nodes.

steam::fixture::test::NodeGraphAttachment_test Class NodeGraphAttachment_test Verify the facade object used to connect from the Segments in the Fixture into the actual render nodes network

• construction of ExitNode
• composition of the NodeGraphAttachment including prerequisites
• generation of a complete setup of fake ExitNodes from a test spec.

steam::fixture::test::NodeGraphAttachment_test Member NodeGraphAttachment_test::access_ExitNodeTree () access to ExitNode and fall back on ExitNode::NIL when undefined

• verify ExitNode::NIL
• build a simple ExitNode without prerequisites
• use this as prerequisite(s) for another ExitNode
• put a third ExitNode(id=13) also into the same collection
• use this to construct a NodeGraphAttachment
• access existing and non-existing index positions

steam::fixture::test::NodeGraphAttachment_test Member NodeGraphAttachment_test::fabricate_MockExitNode () setup a properly structured ExitNode graph using the specification scheme supported by MockSegmentation

steam::engine::test::NodeOperation_test Class NodeOperation_test check render node operation modes and collaboration.

steam::engine::test::NodeSource_test Class NodeSource_test the source reading render node.

lib::test::NullValue_test Class NullValue_test Access "NIL values" just by type, verify these are actually singletons and are indeed created on demand.

lib::test::OpaqueHolder_test Class OpaqueHolder_test use the OpaqueHolder inline buffer to handle objects of a family of types through a common interface, without being forced to use heap storage or a custom allocator.

lib::test::OpaqueHolder_test Member OpaqueHolder_test::checkHandling (TestList &objs) cover the basic situations of object handling, especially copy operations and re-assignments

lib::test::OpaqueHolder_test Member OpaqueHolder_test::checkSpecialSubclass () OpaqueHolder with additional storage for subclass.

Moreover, if the concrete class has a custom operator bool(), it will be invoked automatically from OpaqueHolder's operator bool()

lib::test::OpaqueUncheckedBuffer_test Class OpaqueUncheckedBuffer_test use an inline buffer to place objects of a subclass, without any checks.

lib::test::OptionalRef_test Class OptionalRef_test verify a reference-like wrapper class, used to provide a switchable link to an already existing object.

steam::asset::test::OrderingOfAssets_test Class OrderingOfAssets_test validate the equality and order relations of Asset::Ident and Asset objects.

steam::mobject::test::OutputMapping_test Class OutputMapping_test create a synthetic / example mapping to verify generic mapping behaviour.

steam::play::test::OutputSlotProtocol_test Class OutputSlotProtocol_test verify the OutputSlot interface and base implementation by performing full data exchange cycle.

lib::test::PathArray_test Class PathArray_test verify abstraction wrapper to handle some char pointers in the way of a standard sequence container with iteration and range checks.

lib::test::PathArray_test Member PathArray_test::verify_boundaries () cover some tricky corner cases of the bound checks and normalisation routine.

lib::test::PathArray_test Member PathArray_test::verify_comparisons () verify equality comparison Equality of PathArray is based on overall size, position and normalised content.

steam::mobject::session::test::PlacementBasic_test Class PlacementBasic_test basic behaviour of Placements and access to MObjects.

steam::mobject::session::test::PlacementHierarchy_test Class PlacementHierarchy_test creating placements specifically typed, forming an hierarchy of placement types which loosely mirrors the hierarchy of the pointee types.

steam::mobject::session::test::PlacementIndex_test Class PlacementIndex_test basic behaviour of the index mechanism used to keep track of individual Placements as added to the current Session.

steam::mobject::session::test::PlacementIndex_test Member PlacementIndex_test::checkContentsEnumeration (Idx index) drill down into the tree-like structure and enumerate the contents of each element, if any

steam::mobject::session::test::PlacementIndexQuery_test Class PlacementIndexQuery_test accessing the PlacementIndex through the generic query interface, for discovering scope contents and containing scope.

steam::mobject::test::PlacementObjectIdentity_test Class PlacementObjectIdentity_test verify correct handling of object identity.

steam::mobject::session::test::PlacementRef_test Class PlacementRef_test properties and behaviour of the reference-mechanism for Placements.

steam::mobject::session::test::PlacementScope_test Class PlacementScope_test basic behaviour of the nested placement search scopes.

steam::mobject::session::test::PlacementScope_test Member PlacementScope_test::verifyEquality () equality of scopes is based on the ID of the scope top (Placement)

steam::mobject::session::test::PlacementScope_test Member PlacementScope_test::verifyLookup (PPIdx sess) for each Placement in our test "session", find the scope and verify it's in line with the index

steam::mobject::session::test::PlacementScope_test Member PlacementScope_test::verifyNavigation (PPIdx sess) for each element in our test session, establish the scope and retrieve the path to root, verifying the parent relationships as we go up.

lib::test::PolymorphicValue_test Class PolymorphicValue_test build a bunch of PolymorphicValue objects.

lib::test::PolymorphicValue_test Member PolymorphicValue_test::verifyCopySupportDetectionMetafunctions () internally, PolymorphicValue uses some metafunctions to pick a suitable code path, based on the presence of helper functions on the API of the embedded objects.

lib::time::test::QuantiserBasics_test Class QuantiserBasics_test cover the basic Quantiser API.

steam::mobject::session::test::QueryFocus_test Class QueryFocus_test handling of current query focus when navigating a system of nested scopes.

steam::mobject::session::test::QueryFocus_test Member QueryFocus_test::checkNavigation (QueryFocus &focus) move the current focus to different locations and discover contents there.

steam::mobject::session::test::QueryFocus_test Member QueryFocus_test::manipulate_subFocus () side-effect free manipulation of a sub-focus, while the original focus is pushed aside (stack)

steam::mobject::session::test::QueryFocusStack_test Class QueryFocusStack_test behaviour of the stack of focus location paths.

lumiera::test::QueryResolver_test Class QueryResolver_test verify the mechanism for issuing typed queries through a generic interface, without disclosing the facility actually answering those queries.

lib::test::QueryText_test Class QueryText_test cover basic properties of the generic syntactical query representation.

lib::query::test::QueryUtils_test Class QueryUtils_test check the various small helpers and utilities we utilise for dealing with ConfigQuery

lib::query::test::QueryUtils_test Member QueryUtils_test::check_countPred () counting of predicates in a query (currently 4/08 regexp based...)

lib::query::test::QueryUtils_test Member QueryUtils_test::check_extractID () the simple regexp extracting a parameter token

lib::query::test::QueryUtils_test Member QueryUtils_test::check_normaliseID () sanitising and normalising various tokens

lib::query::test::QueryUtils_test Member QueryUtils_test::check_removeTerm () the regexp based cutting of a term with given symbol

lib::test::Random_test Class Random_test demonstrate simple access to random number generation, as well as the setup of controlled random number sequences.

lib::test::Random_test Member Random_test::simpleUsage () demonstrate usage of default random number generators

lib::test::Random_test Member Random_test::verify_reproducibleSequence () demonstrate that random number sequences can be reproduced

• use a rigged SeedNucleus, always returning a fixed sees
• build two distinct random sequence generators, yet seeded from the same source; they will produce the same sequence
• sequences can be re-shuffled by a seed value, so that the following random numbers will start to differ
• but even this re-shuffling is deterministic

lib::test::RandomDraw_test Class RandomDraw_test Verify a flexible builder for random-value generators; using a config template, these can be outfitted to use a suitable source of randomness and to produce values from a desired target type and limited range.

lib::test::RandomDraw_test Member RandomDraw_test::simpleUse () demonstrate a basic usage scenario

lib::test::RandomDraw_test Member RandomDraw_test::verify_adaptMapping () bind custom mapping transformation functions.

lib::test::RandomDraw_test Member RandomDraw_test::verify_dynamicChange () change the generation profile dynamically, based on current input; in the example here, the probability is manipulated in each cycle.

lib::test::RandomDraw_test Member RandomDraw_test::verify_numerics () verify random number transformations.

lib::test::RandomDraw_test Member RandomDraw_test::verify_policy () verify configuration through policy template

• use the default policy, which takes no input values, but rather directly generates a random number; in this case here, input values are ∈ [0 .

util::test::Rational_test Class Rational_test cover some aspects of working with fractional numbers.

util::test::Rational_test Member Rational_test::demonstrate_basics () demonstrate fundamental properties of rational arithmetics as provided by boost::rational

• represent rational fractions precisely
• convert to other types and then perform the division
• our typedef Rat = boost::rational<int64_t>
• our user-defined literal "_r" to simplify notation
• string conversion to reveal numerator and denominator
• automatic normalisation and reduction
• some typical fractional calculation examples.

util::test::Rational_test Member Rational_test::verify_intLog2 () an optimised implementation of integer binary logarithm

• basically finds the highest bit which is set
• can be used with various integral types
• performs better than using the floating-point solution

util::test::Rational_test Member Rational_test::verify_limits () demonstrate the limits and perils of rational fractions

• largest and smallest number representable
• numeric overflow due to normalisation
• predicates to check for possible trouble

util::test::Rational_test Member Rational_test::verify_requant () helper to re-quantise a rational fraction

• recast a number in terms of another denominator
• this introduces an error of known limited size
• and is an option to work around "poisonous" fractions

steam::mobject::session::test::RebuildFixture_test Class RebuildFixture_test (re)building the ExplicitPlacement objects from the objects placed into the Session/Model.

lib::test::RefArray_test Class RefArray_test build several wrappers, each based on a different storage, all providing RefArray access to a given vector.

util::test::RemoveFromSet_test Member RemoveFromSet_test::test_remove (string elems_to_remove) populate a test set, remove the denoted elements and print the result...

steam::test::RenderSegment_test Class RenderSegment_test create a render process from a given segment of the Session.

lib::wrapper::test::ReplaceableItem_test Class ReplaceableItem_test scrutinise an adapter to snapshot non-assignable values.

lib::wrapper::test::ReplaceableItem_test Member ReplaceableItem_test::verifyNonComparableElements () verify we can handle elements without comparison operator

lib::wrapper::test::ReplaceableItem_test Member ReplaceableItem_test::verifyOnlyMoveConstructible () handle elements that allow nothing but move construction

lib::wrapper::test::ReplaceableItem_test Member ReplaceableItem_test::verifySaneInstanceHandling () verify that ctor and dtor calls are balanced, even when assigning and self-assigning.

lib::wrapper::test::ReplaceableItem_test Member ReplaceableItem_test::verifyWrappedPtr () verify especially that we can handle and re-"assign" an embedded pointer

lib::test::Result_test Class Result_test Verify an intermediary »Either« type, to embody either a successful result, or document a failure with encountered exception.

vault::gear::test::SchedulerActivity_test Class SchedulerActivity_test verify behaviour of the Scheduler Activity Language.

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::dispatchChain () verify the ability to dispatch and perform a chain of activities.

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::scenario_IOJob () usage scenario: Activity graph for an async Job

• use a simple calculation job term as follow-up receiver
• build an activity Term based on the »Async Load Job« wiring and link it to the receiver
• also retrieve the Activity record used as re-entrance point after completing async IO

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::scenario_MetaJob () usage scenario: Activity graph for administrative job

• by default, neither Gate, nor start/stop notification used
• rather, the INVOKE and the argument-FEED is posted directly

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::scenario_Notification () usage scenario: Notification from prerequisite Jobs within time window

• build similar »CalculationJob« wiring
• configure extended dependency notification capabilities
• Case-1 : a Notification decreases the latch, but blocks otherwise
• Case-2 : when the primary chain is activated after the Notification, then the tail chain behind the Gate is dispatched

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::scenario_RenderJob () usage scenario: Activity graph for a simple render job

• build an activity term based on the »CalculationJob« wiring template
• dispatch the generated Activity chain and verify sequence of invocations

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::simpleUsage () demonstrate simple Activity usage

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::termBuilder () verify the Activity term builder

• use the builder syntax to define a simple Activity chain
• verify the basic outfitting and sane connectivity
• verify values reported by the BlockFlow allocator
• ensure the defined Job can be properly invoked

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::verifyActivity_Gate_block () behaviour of Activity::GATE: the count-down condition determines if activation passes; otherwise the Gate will just return activity::SKIP

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::verifyActivity_Gate_dead () behaviour of Activity::GATE: the rest of the chain is just skipped in case of deadline violation

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::verifyActivity_Gate_notify () behaviour of Activity::GATE:

• if it is dispatched as new chain, instead of just activating it of part of an ongoing chain, the Gate will receive a notification
• this results in decrementing the prerequisite latch in the Gate
• what happens then depends on current state; in this test case the Gate is decremented yet remains closed

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::verifyActivity_Gate_opened () behaviour of Activity::GATE on notification

• Gate configured initially such that it blocks (without violating deadline)
• thus a regular activation signals to skip the chain.

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::verifyActivity_Gate_pass () behaviour of Activity::GATE: if conditions are met, the activation is just passed, so the executor (in the Scheduler) will just invoke the chain

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::verifyActivity_Invoke () behaviour of Activity::INVOKE

• setup requires two FEED-Activities to be chained up as arguments
• use the rigged execution context provided by ActivityDetector
• can verify this way that the activation leads to JobFunctor invocation

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::verifyActivity_Notify () behaviour of Activity::NOTIFY when activated

• notification is dispatched as special message to an indicated target Activity
• when activated, a NOTIFY-Activity invokes the λ-post with its target,
• in the actual setup (Scheduler) this leads to dispatching of said target Activity
• what happens then depends on the target; usually the target is a GATE
• in first example here, we just use a TICK-Activity
• for a GATE there is special treatment to inject the timing window of the target into the CTX-post invocation; this is essential to handle long notification-chains properly.

vault::gear::test::SchedulerActivity_test Member SchedulerActivity_test::verifyActivity_Post () behaviour of Activity::POST

• invoke the λ-post to dispatch the chain through the queue
• the chain to be executed is given as next
• time window for scheduling as data field
• the start time from this window becomes the when parameter
• the now parameter from the activation is thus ignored

vault::gear::test::SchedulerCommutator_test Class SchedulerCommutator_test Scheduler Layer-2: coordination of Activity execution.

vault::gear::test::SchedulerCommutator_test Member SchedulerCommutator_test::demonstrateSimpleUsage () demonstrate a simple usage scenario

vault::gear::test::SchedulerCommutator_test Member SchedulerCommutator_test::integratedWorkCycle () step-wise perform the typical sequence of planning and worker activation

• use the Render-Job scenario from SchedulerActivity_test::scenario_RenderJob()
• use similar instrumentation to trace Activities
• specifically rig the diagnostic executionCtx to drop the GroomingToken at λ-work
• Step-1 : schedule the Activity-term
• Step-2 : later search for work, retrieve and dispatch the term
• verify the expected sequence of Activities actually occurred

vault::gear::test::SchedulerCommutator_test Member SchedulerCommutator_test::torture_GroomingToken () ensure the GroomingToken mechanism indeed creates mutual exclusion to protected against concurrent corruption.

vault::gear::test::SchedulerCommutator_test Member SchedulerCommutator_test::verify_dispatch () verify basic functionality to dequeue and dispatch entries.

vault::gear::test::SchedulerCommutator_test Member SchedulerCommutator_test::verify_findWork () verify the logic to decide where and when to perform the dispatch of a Scheduler Activity chain.

verify logic of queue updates and work prioritisation.

vault::gear::test::SchedulerCommutator_test Member SchedulerCommutator_test::verify_GroomingGuard () verify extended logic to protect a scope

• if the thread already holds the grooming token, nothing happens
• otherwise, it is acquired (blocking) and dropped on exit

vault::gear::test::SchedulerCommutator_test Member SchedulerCommutator_test::verify_GroomingToken () verify logic to control concurrent execution

vault::gear::test::SchedulerCommutator_test Member SchedulerCommutator_test::verify_postChain () verify entrance point for performing an Activity chain.

vault::gear::test::SchedulerCommutator_test Member SchedulerCommutator_test::verify_Significance () verify that obsoleted or rejected entries are dropped transparently

• add entries providing extra information regarding significance
• verify that missing the deadline is detected
• entries past deadline will be dropped when pulling for work
• entries tagged with an ManifestationID can be disabled and will be automatically disposed.

vault::gear::test::SchedulerInterface_test Class SchedulerInterface_test verify and demonstrate the organisation of the high-level interface for defining jobs to be invoked by the scheduler.

vault::gear::test::SchedulerInterface_test Member SchedulerInterface_test::demonstrate_nested_job_specification (SchedulerFrontend &scheduler) demonstrate how a tree of dependent render jobs can be handed over to the scheduler within a single "transaction"

vault::gear::test::SchedulerInvocation_test Class SchedulerInvocation_test Scheduler Layer-1: queue processing and invocation by priority.

vault::gear::test::SchedulerInvocation_test Member SchedulerInvocation_test::simpleUsage () demonstrate a simple usage scenario of data passing

vault::gear::test::SchedulerInvocation_test Member SchedulerInvocation_test::verify_isDue () the entry appearing at head is due when its time is at or before current time.

vault::gear::test::SchedulerInvocation_test Member SchedulerInvocation_test::verify_Queuing () verify records are passed properly through the queues

• add multiple elements to the instruct queue
• after feedPrioritisation these appear as output

vault::gear::test::SchedulerInvocation_test Member SchedulerInvocation_test::verify_Significance () verify extended classification data and information functions at scheduler head

• add entries providing extra information regarding significance
• verify that missing the deadline is detected
• entries past deadline are marked outdated (will be dropped by Layer-2)
• entries can be tagged with an ManifestationID, allowing to enable or disable visibility for a »family« of schedule entries
• use the flag for compulsory entries, allowing to detect a fatal jammed situation where the head entry is out of time, while marked mandatory to process.

vault::gear::test::SchedulerInvocation_test Member SchedulerInvocation_test::verify_stability () sort order is not necessarily stable if using identical time specs on entrance

vault::gear::test::SchedulerInvocation_test Member SchedulerInvocation_test::verify_WaterLevel () verify the given time point is utilised for prioritisation

• order at output is determined by the time spec
• even later added elements can push back previously visible elements at head

vault::gear::test::SchedulerLoadControl_test Class SchedulerLoadControl_test verify behaviour patterns relevant for Scheduler load control.

vault::gear::test::SchedulerLoadControl_test Member SchedulerLoadControl_test::classifyCapacity () verify allocation decision for free capacity

• due and overdue Activities are prioritised
• keep spinning when next Activity to schedule is very close
• otherwise, priority is to tend for the next known Activity
• beyond that, free capacity is redistributed according to horizon
• for incoming free capacity there is a preference to keep it sleeping, to allow for disposing of excess capacity after extended sleep time

vault::gear::test::SchedulerLoadControl_test Member SchedulerLoadControl_test::classifyHorizon () verify classification of time horizon for scheduling.

vault::gear::test::SchedulerLoadControl_test Member SchedulerLoadControl_test::indicateAverageLoad () verify fusion of sampled observations to guess average scheduler load

• use a rigged wiring of the load controller to verify calculation based on known values of current concurrency and schedule pressure
• scheduling on average 200µs behind nominal schedule is considered the regular balanced state and thus defined as 100% schedule pressure
• if congestion builds up to 1/10 of WORK_HORIZON, 200% overload is indicated
• on the other hand, if workers appear on average 200µs before the typical balanced state, the resulting headroom is defined to constitute 50% pressure
• the pressure value is multiplied with the degree of concurrency
• the pressure is sampled from the lag (distance of current time to the next activity to schedule), which is observed whenever a worker calls in to retrieve more work.

vault::gear::test::SchedulerLoadControl_test Member SchedulerLoadControl_test::scatteredReCheck () verify the re-distribution of free capacity by targeted delay

• the implementation uses the next-tended start time as anchor point
• capacity classes which should be scheduled right away will actually never call this function — yet still a sensible value is returned here
• capacity targeted at current work will be redistributed behind the next-tended time, and within a time span corresponding to the work realm
• capacity targeted towards more future work will be distributed within the horizon defined by the sleep-cycle
• especially for capacity sent to sleep, this redistribution works without being shifted behind the next-tended time, since in that case the goal is to produce a random distribution of the »sleeper« callbacks.

vault::gear::test::SchedulerLoadControl_test Member SchedulerLoadControl_test::simpleUsage () TODO demonstrate a simple usage scenario

vault::gear::test::SchedulerLoadControl_test Member SchedulerLoadControl_test::tendNextActivity () verify the mark for tended next head Activity.

vault::gear::test::SchedulerService_test Class SchedulerService_test Scheduler component integration test: use the service API for state control and to add Jobs and watch processing patterns.

vault::gear::test::SchedulerService_test Member SchedulerService_test::invokeWorkFunction () verify visible behaviour of the work-pulling function

• use a rigged Activity probe to capture the schedule time on invocation
• additionally perform a timing measurement for invoking the work-function
• invoking the Activity probe itself costs 50...150µs, Scheduler internals < 50µs
• this implies we can show timing-delay effects in the millisecond range
• demonstrated behaviour
  • an Activity already due will be dispatched immediately by post()
  • an Activity due at the point when invoking the work-function is dispatched
  • while queue is empty, the work-function returns immediately, indicating sleep
  • invoking the work-function, when there is still some time span up to the next planned Activity, will cause a targeted sleep, returning shortly after the next schedule.

vault::gear::test::SchedulerService_test Member SchedulerService_test::processSchedule () schedule and process a complete work load

• use a complex computation structure generated by TestChainLoad
• dispatch 64 jobs, each depending more or less on its predecessors
• processing proceeds first in two parallel chains, then joins and forks again into a massive overload towards the end.

vault::gear::test::SchedulerService_test Member SchedulerService_test::scheduleRenderJob () Schedule a render job through the high-level Job-builder API.

vault::gear::test::SchedulerService_test Member SchedulerService_test::simpleUsage () demonstrate a simple usage scenario

vault::gear::test::SchedulerService_test Member SchedulerService_test::verify_LoadFactor () verify the scheduler processes scheduled events, indicates current load and winds down automatically when falling empty.

vault::gear::test::SchedulerService_test Member SchedulerService_test::verify_StartStop () get the scheduler into running state

vault::gear::test::SchedulerStress_test Class SchedulerStress_test Investigate and verify non-functional characteristics of the Scheduler.

vault::gear::test::SchedulerStress_test Member SchedulerStress_test::investigateWorkProcessing () use an extended load pattern to emulate a typical high work load

• using 4-step linear chains, interleaved such that each level holds 4 nodes
• the structure overall spans out to 66 levels, leading to ∅3.88 nodes/level
• load on each node is 5ms, so the overall run would take ~330ms back to back
• this structure is first performed on the bench::BreakingPoint
• in the second part, a similar structure with 4-times the size is performed as a single run, but this time with planning and execution interleaved.

vault::gear::test::SchedulerStress_test Member SchedulerStress_test::search_breaking_point () determine the breaking point towards scheduler overload

• use the integrated StressRig
• demonstrate how parameters can be tweaked
• perform a run, leading to a binary search for the breaking point

vault::gear::test::SchedulerStress_test Member SchedulerStress_test::setup_systematicSchedule () build a scheme to adapt the schedule to expected runtime.

vault::gear::test::SchedulerStress_test Member SchedulerStress_test::smokeTest () demonstrate test setup for sustained operation under load

vault::gear::test::SchedulerStress_test Member SchedulerStress_test::verify_instrumentation () verify capability for instrumentation of job invocations

vault::gear::test::SchedulerStress_test Member SchedulerStress_test::watch_expenseFunction () Investigate the relation of run time (expense) to input length.

vault::gear::test::SchedulerUsage_test Class SchedulerUsage_test Ensure expected Scheduler functionality in standard usage situations.

vault::gear::test::SchedulerUsage_test Member SchedulerUsage_test::setupLalup () TODO

vault::gear::test::SchedulerUsage_test Member SchedulerUsage_test::simpleUsage () TODO demonstrate a simple usage scenario

vault::gear::test::SchedulerUsage_test Member SchedulerUsage_test::walkingDeadline () TODO

lib::test::ScopedCollection_test Class ScopedCollection_test ScopedCollection manages a fixed set of objects, but these child objects are noncopyable, may be polymorphic, an can be created either all at once or chunk wise.

lib::test::ScopedCollection_test Member ScopedCollection_test::building_RAII_Style () using the ScopedCollection according to the RAII pattern.

lib::test::ScopedCollection_test Member ScopedCollection_test::building_StackStyle () using the ScopedCollection to hold a variable and possibly increasing number of elements, within the fixed limits of the maximum capacity defined by the ctor parameter.

lib::test::ScopedCollection_test Member ScopedCollection_test::verify_defaultPopulator () for using ScopedCollection in RAII style, several pre-defined "populators" are provided.

lib::test::ScopedCollection_test Member ScopedCollection_test::verify_embeddedCollection () simulate the typical situation of a manager owning some embedded components.

lib::test::ScopedHolder_test Class ScopedHolder_test ScopedHolder and ScopedPtrHolder are initially empty and copyable.

lib::test::ScopedHolder_test Member ScopedHolder_test::checkSTLContainer () collection of noncopyable objects maintained within a STL map

lib::test::ScopedHolderTransfer_test Class ScopedHolderTransfer_test growing a vector containing noncopyable objects wrapped into ScopedHolder instances.

lib::test::ScopedPtrVect_test Class ScopedPtrVect_test ScopedPtrVect manages the lifecycle of a number of objects.

steam::mobject::session::test::ScopePath_test Class ScopePath_test properties and behaviour of the path of nested scopes.

steam::mobject::session::test::ScopePath_test Member ScopePath_test::check_RefcountProtection (PMO &refPlacement) the embedded refcount is handled sensibly when it comes to copying.

steam::mobject::session::test::ScopePath_test Member ScopePath_test::navigate (const ScopePath refPath, PPIdx index) modify a path by navigating it.

steam::mobject::session::test::ScopeQuery_test Class ScopeQuery_test how to discover contents or location of a container-like part of the high-level model.

lib::test::SearchPathSplitter_test Class SearchPathSplitter_test verify splitting a search path specification and retrieving the components by iteration.

steam::fixture::test::SegmentationIntegration_test Class SegmentationIntegration_test Properties and behaviour of a complete Segmentation data structure.

steam::control::test::SessionCommandFunction_test Class SessionCommandFunction_test verify integrated functionality of command dispatch through the SessionCommand facade.

steam::control::test::SessionCommandFunction_test Member SessionCommandFunction_test::perform_massivelyParallel (Arg args_for_stresstest) massively multithreaded torture test to verify that commands are properly enqueued and executed one by one

• create several threads to send random command messages
• verify that, after executing all commands, the internal state variable reflects the result of a proper sequential calculation and summation

steam::control::test::SessionCommandFunction_test Member SessionCommandFunction_test::perform_messageInvocation () invoke a command in the same way as CoreService does when handling command messages from the UI-Bus

• build a command message, similar to what the generic UI element does
• use the contents of this message at the SessionCommand facade, similar to what CoreService does

steam::control::test::SessionCommandFunction_test Member SessionCommandFunction_test::perform_simpleInvocation () demonstrate a simple direct invocation

steam::control::test::SessionCommandFunction_test Member SessionCommandFunction_test::startDispatcher () start the session loop thread, similar to what the »session subsystem« does

steam::control::test::SessionCommandFunction_test Member SessionCommandFunction_test::stopDispatcher () verify the »session loop thread« has finished properly

steam::mobject::session::test::SessionElementQuery_test Class SessionElementQuery_test cover the part of the session API allowing to retrieve specific elements by query.

steam::mobject::session::test::SessionElementTracker_test Class SessionElementTracker_test verify the tracking of special session/model elements, to be exposed through an self-contained interface module on the session API.

steam::mobject::session::test::SessionElementTracker_test Member SessionElementTracker_test::verify_cleanup (PTimeline const &aTimeline_in_session) ensure the asset cleanup doesn't interfere with session shutdown

steam::mobject::session::test::SessionManager_test Member SessionManager_test::clearSession () clear current session contents without resetting global session config.

steam::mobject::session::test::SessionManager_test Member SessionManager_test::getCurrentSession () accessing the current (global) session

steam::mobject::session::test::SessionManager_test Member SessionManager_test::loadMockSession () use a mock session serialiser to load a preconfigured test session.

steam::mobject::session::test::SessionManager_test Member SessionManager_test::loadSession (const string &src) load serialised session using the real session serialiser implementation.

steam::mobject::session::test::SessionManager_test Member SessionManager_test::resetSession () reset global session config and start with a pristine default session.

steam::mobject::session::test::SessionManager_test Member SessionManager_test::saveSession (string &dest) serialise (save) the current session

steam::mobject::session::test::SessionModifyParts_test Class SessionModifyParts_test perform the most important structural modifications on a session and verify they're carried out properly.

steam::mobject::session::test::SessionServiceAccess_test Member SessionServiceAccess_test::access_defaultSession () accessing an non-existing session causes creation of a new TSessionImpl instance.

steam::mobject::session::test::SessionServiceAccess_test Member SessionServiceAccess_test::invoke_implServices () accessing implementation-level APIs

steam::mobject::session::test::SessionServiceAccess_test Member SessionServiceAccess_test::make_newSession () invoking the management API to close the session.

steam::mobject::session::test::SessionStructure_test Class SessionStructure_test access the current session and verify the correct structure of the most important components: The session contains an Sequence, we can get at the Fixture, we have at least one Fork and the corresponding Fork-ID (asset) can be retrieved.

lib::test::SimpleAllocator_test Class SimpleAllocator_test cover the basic operations of a custom allocator, delegating to mpool.

lib::test::Singleton_test Class Singleton_test implement a Singleton class using our Singleton Template.

lib::test::SingletonSubclass_test Class SingletonSubclass_test specific dependency-injection setup, to create a singleton subclass (implementation class) instance, without coupling the caller to the concrete type.

lib::test::SingletonTestMock_test Class SingletonTestMock_test inject a Mock object into the Singleton Factory, to be returned and used in place of the original object.

vault::gear::test::SpecialJobFun_test Class SpecialJobFun_test verify a self-managing one-time render job functor.

vault::gear::test::SpecialJobFun_test Member SpecialJobFun_test::simpleUsage () demonstrate simple usage by λ-binding

vault::gear::test::SpecialJobFun_test Member SpecialJobFun_test::verifyLifecycle () verify storage and lifecycle management

• use a instance-tracking marker implanted into the functor
• verify no memory is leaked and the tracker instance is deallocated
• verify the single tracker instance indeed lives in the JobFunctor
• investigate the usage count of the front-end handle
• verify the front-end can be copied without impact on the JobFunctor
• verify the heap allocated functor keeps itself alive even when the front-end handle is already gone.

lib::test::SplitSplice_test Class SplitSplice_test verify proper working of a generic procedure to splice an interval into a complete segmentation of an ordered axis into seamless intervals.

lib::test::SplitSplice_test Member SplitSplice_test::demonstrate_usage () demonstrate how to use the »Split-Splice« algorithm with custom data

lib::test::SplitSplice_test Member SplitSplice_test::verify_cornerCases () cover special and boundary cases

lib::test::SplitSplice_test Member SplitSplice_test::verify_integrity () verify instance data is properly handled on split operation

• segments not touched will stay at same memory location
• any adapted segments will be new allocated objects
• yet segments cloned / split will carry on all data

lib::test::SplitSplice_test Member SplitSplice_test::verify_standardCases () cover all possible cases of splicing an interval

lib::test::SplitSplice_test Member SplitSplice_test::verify_testFixture () verify the fixture and self-diagnostics for this test

stage::ctrl::test::StateMapGroupingStorage_test Class StateMapGroupingStorage_test verify the storage structure for capturing UI state works as intended.

lib::stat::test::Statistic_test Class Statistic_test verifies the proper working of statistic helper functions.

lib::stat::test::Statistic_test Member Statistic_test::check_baseStatistics () helpers to calculate mean and standard derivation

lib::stat::test::Statistic_test Member Statistic_test::check_TimeSeriesLinearRegression () regression over a series of measurement data

• use greater mount of data generated with randomness
• actually a power function is hidden in the data

lib::stat::test::Statistic_test Member Statistic_test::check_wightedLinearRegression () attribute a weight to each data point going into linear regression

• using a simple scenario with three points
• a line with gradients would run through the end points (1,1) ⟶ (5,5)
• but we have a middle point, offset by -2 and with double weight
• thus the regression line is overall shifted by -1
• standard derivation is √3 and correlation 81% (both plausible and manually checked

lib::stat::test::Statistic_test Member Statistic_test::demonstrate_DataSpan () a simplified preview on C++20 ranges

steam::test_format::StreamTypeBasics_test Class StreamTypeBasics_test check the basic workings of the stream type handling.

steam::test_format::StreamTypeLifecycle_test Class StreamTypeLifecycle_test check the stream type registration lifecycle.

steam::test_format::StreamTypeLifecycle_test Member StreamTypeLifecycle_test::check_pristineState () this test defines a new (dummy) type info and schedules it for setup in the pristine state; check this info is actually present after resetting the stream type manager, while other additional info not scheduled in this manner is not present in this state

steam::test_format::StreamTypeLifecycle_test Member StreamTypeLifecycle_test::register_additional_TypeInfo () use the stream type manager to register additional type info and verify it is used in type resolution.

lib::test::SubID_test Class SubID_test for now (9/09) this is a playground for shaping a vague design idea

• base types and casts
• exploring some extensions
• use this ID as Hash-Map key

lumiera::test::SubsystemRunner_test Class SubsystemRunner_test managing start and stop of several dependent "subsystems" under various conditions.

lib::test::Symbol_test Class Symbol_test properties of Literal and Symbol data types.

lib::test::Symbol_test Member Symbol_test::use_as_map_key () use Literal and Symbol as keys in a tree map.

lib::test::SymbolHashtable_test Class SymbolHashtable_test build a hashtable using Symbol objects as Keys.

lib::test::SyncBarrier_test Class SyncBarrier_test verify N-fold synchronisation points by multi-thread loat-test.

lib::test::SyncBarrierPerformance_test Class SyncBarrierPerformance_test investigate performance of N-fold thread synchronisation.

lib::test::SyncBarrierPerformance_test Member SyncBarrierPerformance_test::run (Arg) performance investigation of N-fold synchronisation barrier

lib::test::SyncClasslock_test Class SyncClasslock_test check proper handling of class (not instance)-based Monitor locks.

lib::test::SyncLocking_test Class SyncLocking_test verify the object monitor provides locking and to prevent data corruption on concurrent modification of shared storage.

lib::test::SyncTimedwait_test Class SyncTimedwait_test timeout feature on condition wait as provided by the underlying implementation and accessible via the object monitor based locking/waiting mechanism.

lib::test::SyncWaiting_test Class SyncWaiting_test concurrent waiting and notification, implemented via object monitor.

lib::test::test::TempDir_test Class TempDir_test validate proper behaviour of a temporary working directory, including automatic name allocation and clean-up.

lib::test::test::TempDir_test Member TempDir_test::verify_Lifecycle () automatic clean-up even in case of errors.

vault::gear::test::TestChainLoad_test Class TestChainLoad_test verify a tool to generate synthetic load for Scheduler tests.

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::showcase_Expansion () demonstrate shaping of generated topology

• the expansion rule injects forking nodes
• after some expansion, width limitation is enforced
• thus join nodes are introduced to keep all chains connected
• by default, the hash controls shape, evolving identical in each branch
• with additional shuffling, the decisions are more random
• statistics can be computed to characterise the graph
• the graph can be visualised as Graphviz diagram

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::showcase_PruneChains () demonstrate topology with pruning and multiple segments

• the prune rule terminates chains randomly
• this can lead to fragmentation into several sub-graphs
• these can be completely segregated, or appear interwoven
• equilibrium of seeding and pruning can be established

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::showcase_Reduction () demonstrate impact of reduction on graph topology

• after one fixed initial expansion, reduction causes all chains to be joined eventually
• expansion and reduction can counterbalance each other, leading to localised »packages« of branchings and reductions

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::showcase_SeedChains () demonstrate shaping of generated topology by seeding new chains

• the seed rule allows to start new chains in the middle of the graph
• combined with with reduction, the emerging structure resembles the processing pattern encountered with real media calculations

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::showcase_StablePattern () examples of realistic stable processing patterns

• some cases achieve a real equilibrium
• other examples' structure is slowly expanding and become stable under constriction of width
• some examples go into a stable repetitive loop
• injecting additional randomness generates a chaotic yet stationary flow of similar patterns

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::usageExample () demonstrate simple usage of the test-load

• build a graph with 64 nodes, grouped into small segments
• use a scheduler instance to »perform« this graph

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::verify_adjusted_schedule () verify use of computation weights and topology to establish a predicted load pattern, which can be used to construct a schedule adapted to the expected load.

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::verify_computation_load () verify calibration of a configurable computational load.

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::verify_Node () data structure to represent a computation Node

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::verify_reseed_recalculate () set and propagate seed values and recalculate all node hashes.

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::verify_runtime_reference () compute synchronous execution time for reference

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::verify_scheduling_setup () setup for running a chain-load as scheduled task

• running an isolated Node recalculation
• dispatch of this recalculation packaged as render job
• verify the planning job, which processes nodes in batches; for the test, the callback-λ will not invoke the Scheduler, but rather use the instructions to create clone nodes; if all nodes are processed and all dependency connections properly reported through the callback-λ, then calculating this clone network should reproduce the original hash.

vault::gear::test::TestChainLoad_test Member TestChainLoad_test::verify_Topology () build topology by connecting the nodes

• pre-allocate a block with 32 nodes and then build a topology to connect these, using default rules
• in the default case, nodes are linearly chained
• hash is also computed by chaining with predecessor hash
• hash computations can be reproduced

steam::engine::test::TestFrame_test Class TestFrame_test verify test helper for engine tests: a dummy data frame.

steam::engine::test::TestFrame_test Member TestFrame_test::useFrameTable () the table of test frames computed on demand

steam::engine::test::TestFrame_test Member TestFrame_test::verifyFrameSeries () build sequences of test frames, organised into multiple families (channels).

lib::test::test::TestHelper_test Member TestHelper_test::checkLocalManipulation () check a local manipulations, which are undone when leaving the scope.

lib::test::test::TestHelper_test Member TestHelper_test::checkThrowChecker () check the VERIFY_ERROR macro, which ensures a given error is raised.

lib::test::test::TestHelper_test Member TestHelper_test::checkTypeDisplay () prints "sizeof()" including some type name.

lib::test::test::TestHelperVariadic_test Class TestHelperVariadic_test document usage of the diagnostics helper for variadic templates.

test::TestOption_test Class TestOption_test for test::TestOption, parsing of commandline options

test::TestOption_test Member TestOption_test::doIt (const string cmdline) performs the actual test for the option parser test::TestOption

lib::test::TextTemplate_test Class TextTemplate_test verify a minimalistic text substitution engine with flexible data binding, used for tool integration and script generation

• cover the core parsing and templating functionality, using a direct binding
• demonstrate the default-binding for a data map
• cover the binding to Lumiera's »External Tree Description«

lib::test::TextTemplate_test Member TextTemplate_test::simpeUsage () simple point-and-shot usage...

lib::test::TextTemplate_test Member TextTemplate_test::verify_conditional () Segments of the text-template can be included conditionally, based on interpretation of a controlling key.

lib::test::TextTemplate_test Member TextTemplate_test::verify_ETD_binding () represent the same logical structure as in the preceding test, yet this time as a tree of GenNodes

• value bindings are translated into attribute access
• the iteration now requires an actually nested scope, holding a sequence of child nodes
• each of these nodes constitutes a »data entity«
• when accessing keys from within such a nested scope, attributes of enclosing scopes are visible, unless shadowed by local definition.

lib::test::TextTemplate_test Member TextTemplate_test::verify_instantiation () Compile a template and instantiate with various data bindings.

lib::test::TextTemplate_test Member TextTemplate_test::verify_iteration () Segments of the text-template can be iterated...

lib::test::TextTemplate_test Member TextTemplate_test::verify_Map_binding () build a data binding to a map-of-strings, and verify all the operations used internally by the text-template engine to navigate the data.

lib::test::TextTemplate_test Member TextTemplate_test::verify_parsing () parsing of tag markup and compilation into a sequence of Action-codes

lib::test::ThreadWrapper_test Class ThreadWrapper_test use the lib::Thread wrapper for simplified definition of the thread-function, argument binding and starting of threads.

lib::test::ThreadWrapper_test Member ThreadWrapper_test::demonstrateSimpleUsage () demonstrate simple usage of the thread-wrapper a λ-binding

lib::test::ThreadWrapper_test Member ThreadWrapper_test::verifyConcurrentExecution () verify the thread function is actually performed concurrently

• use a derived Thread object, also holding a local data field
• the thread function sleeps, and then stores the sum of two numbers
• demonstrate that each instance can have a different argument binding
• verify each thread function has actually been invoked once per thread, by comparing a local sum with values collected from the Thread objects,
• moreover measure the overall time required for launching the threads and then waiting for all threads to have terminated and detached; this time must be shorter than all the average sleep times compounded (as if the function was invoked sequentially).

lib::test::ThreadWrapperAutonomous_test Class ThreadWrapperAutonomous_test a variation of the Thread wrapper to launch a detached thread, with automatic memory management for the thread-object..

lib::test::ThreadWrapperAutonomous_test Member ThreadWrapperAutonomous_test::demonstrateSimpleUsage () demonstrate simply launching a λ-function into background

lib::test::ThreadWrapperAutonomous_test Member ThreadWrapperAutonomous_test::verifyMemoryManagement () verify the detached thread autonomously manages its memory.

lib::test::ThreadWrapperJoin_test Class ThreadWrapperJoin_test verify the special flavour of the thread-wrapper, allowing to block waiting on thread end and then pass result or error state.

lib::test::ThreadWrapperLifecycle_test Class ThreadWrapperLifecycle_test verify lifecycle behaviour of threads managed by thread-wrapper.

lib::test::ThreadWrapperLifecycle_test Member ThreadWrapperLifecycle_test::defaultWrapperLifecycle () demonstrate terms of lifecycle for the default case

lib::test::ThreadWrapperLifecycle_test Member ThreadWrapperLifecycle_test::demonstrateExplicitThreadLifecycle () verify a special setup to start a thread explicitly and to track the thread's lifecycle state.

lib::test::ThreadWrapperLifecycle_test Member ThreadWrapperLifecycle_test::verifyThreadLifecycleHooks () attach user provided callback hooks to the thread lifecycle.

lib::test::ThreadWrapperSelfRecognitionTest_test Class ThreadWrapperSelfRecognitionTest_test verify the ability of a thread to detect code executing within the thread itself.

lib::test::TimeBasics_test Class TimeBasics_test sanity check of basic Time handling.

lib::time::test::TimeControl_test Class TimeControl_test use the time::Control to push a sequence of modifications to various time entities; in all cases, a suitable change should be imposed to the target and then a notification signal should be invoked.

lib::time::test::TimeControl_test Member TimeControl_test::verifyMatrix_of_MutationCases (TimeValue const &o, TimeValue const &c) cover all possible combinations of input change values and target time value entities to be handled by time::Control.

lib::time::test::TimeFormats_test Class TimeFormats_test verify handling of grid aligned timecode values.

lib::time::test::TimeFormats_test Member TimeFormats_test::checkSmpte () detailed coverage of SMPTE timecode representation.

lib::time::test::TimeFormats_test Member TimeFormats_test::checkTimecodeUsageCycle () demonstrate a full usage cycle of timecode and time values.

steam::asset::meta::test::TimeGridBasics_test Class TimeGridBasics_test build some simple time grids and verify their behaviour for quantising (grid aligning) time values.

steam::mobject::session::test::TimelineSequenceHandling_test Class TimelineSequenceHandling_test verify retrieval and instance management of the top level facade objects as integrated with the session and high-level model.

lib::time::test::TimeMutation_test Class TimeMutation_test cover all basic cases for mutating a time specification.

lib::time::test::TimeParsing_test Class TimeParsing_test parse textual time specifications given in the supported timecode formats

lib::time::test::TimeQuantisation_test Class TimeQuantisation_test verify handling of quantised time values.

lib::time::test::TimeValue_test Class TimeValue_test verify handling of time values, time intervals.

lib::time::test::TimeValue_test Member TimeValue_test::checkBasicTimeValues (TimeValue org) creating some time values and performing trivial comparisons.

lib::time::test::TimeValue_test Member TimeValue_test::checkMutableTime (TimeValue org) time variables can be used for the typical calculations, like summing and subtracting values, as well as multiplication with a scale factor.

lib::time::test::TimeValue_test Member TimeValue_test::checkTimeConvenience (TimeValue org) additional convenience shortcuts supported especially by the canonical Time values.

lib::time::test::TimeValue_test Member TimeValue_test::checkTimeHash (TimeValue org) calculate a generic hash value from a time spec

steam::play::test::TimingConstraints_test Class TimingConstraints_test document and verify the definition and combining of timing constraints for playback and rendering.

steam::engine::test::Timings_test Class Timings_test document and verify frame timing calculations, which are used in the Player / engine::Dispatcher, to translate a CalcStream into individual node jobs.

steam::engine::test::Timings_test Member Timings_test::verify_next_startPoint () detect boundaries of frame planning chunks for arbitrary chunk duration.

steam::engine::test::Timings_test Member Timings_test::verify_simpleFrameStep () perform the basic dispatch step and verify the generated frame coordinates

steam::engine::test::TrackingHeapBlockProvider_test Class TrackingHeapBlockProvider_test verify a test support facility, used to write mock components to test the lumiera engine.

lib::diff::test::TreeMutator_test Class TreeMutator_test Demonstrate a customisable component for flexible bindings to enable generic tree changing and mutating operations to arbitrary hierarchical data structures.

lib::diff::test::TreeMutatorBinding_test Class TreeMutatorBinding_test Building blocks to map generic changes to arbitrary private data structures.

lib::diff::test::TreeMutatorBinding_test Member TreeMutatorBinding_test::mutateAttribute () translate generic mutation into attribute manipulation

• here we bind directly to data fields local to this scope
• we execute the same diff primitives used in the preceding tests
• yet binding to data fields has certain intrinsic limits; due to the fixed non-dynamic nature of data fields, it is impossible to define an "ordering" and consequently there is no sequence of diff application.
• so the only form of actually applying a change is to invoke the given setter or use the given mechanism to construct a nested mutator.

lib::diff::test::TreeMutatorBinding_test Member TreeMutatorBinding_test::mutateCollection () map mutation primitives onto a STL collection managed locally.

lib::diff::test::TreeMutatorBinding_test Member TreeMutatorBinding_test::mutateDummy () diagnostic binding: how to monitor and verify the mutations applied

lib::diff::test::TreeMutatorBinding_test Member TreeMutatorBinding_test::mutateGenNode () apply mutation primitives to a GenNode tree.

lib::meta::test::TupleHelper_test Class TupleHelper_test Cover various aspects of the integration of our type sequences with the tuple type from the standard library

• verify our generic tuple access decorator
• verify generating tuple types from type list processing
• TODO more helpers to come

lib::meta::test::TupleHelper_test Member TupleHelper_test::check_tuple_from_Typelist () verify the ability to generate tuple types from typelist metaprogramming

• the resulting types are plain flat std::tuple instantiations
• memory layout is identical to a POD, as expected
• our generic string conversion is extended to work with tuples

lib::meta::test::TupleRecordInit_test Class TupleRecordInit_test Metaprogramming: how to unload the contents of a runtime typed variant sequence into ctor arguments of a (compile time typed) tuple.

lib::test::TypedAllocationManager_test Class TypedAllocationManager_test cover the basic implementation of a custom allocator, delegating to mpool.

lib::test::TypedCounter_test Class TypedCounter_test verify the TypedCounter, which allows to maintain a counter-per-type.

lib::test::TypedCounter_test Member TypedCounter_test::tortureTest () verify TypedCounter concurrency safety

• use a set of types Dummy<i> to access a corresponding counter
• run a large number of threads in parallel, each incrementing a randomly picked counter; this is achieved by using a table of »increment operators«, where each one is tied to a specific Dummy.

lib::meta::test::TypeDemangling_test Class TypeDemangling_test verify the demangling of C++ names, as available through the GCC platform ABI.

lib::test::TypedFamilyMemberID_test Class TypedFamilyMemberID_test simplistic unit test to demonstrate generating _member IDs within a family of objects delineated by type.

lib::idi::test::TypedID_test Class TypedID_test outline of an instance registration and accounting service.

lib::meta::test::TypeDisplay_test Class TypeDisplay_test verify post processing of demangled C++ type names.

lib::meta::test::TypeList_test Class TypeList_test try out Loki-style typelist metaprogramming.

lib::meta::test::TypeListGenerator_test Class TypeListGenerator_test check the helpers for dealing with lists-of-types.

lib::meta::test::TypeListManip_test Class TypeListManip_test check utilities for manipulating lists-of-types.

lib::meta::test::TypeListUtil_test Class TypeListUtil_test verify the simple helpers for working with lists-of-types.

lib::meta::test::TypeSeqManipl_test Class TypeSeqManipl_test check the basic utilities for manipulating (fixed) type sequences.

stage::interact::test::UICoord_test Class UICoord_test verify the basic properties of topological UI coordinate specifications.

stage::interact::test::UICoordResolver_test Class UICoordResolver_test verify query and mutation of UICoord in relation to actual UI topology.

stage::interact::test::UICoordResolver_test Member UICoordResolver_test::verify_backingQuery () verify the command-and-query interface backing the resolver.

stage::interact::test::UICoordResolver_test Member UICoordResolver_test::verify_mutateAnchor () mutate given UI coordinates by anchoring them.

stage::interact::test::UICoordResolver_test Member UICoordResolver_test::verify_mutateCoverage () path matching algorithm to resolve UI coordinates with wildcards against the current UI structure tree.

stage::interact::test::UICoordResolver_test Member UICoordResolver_test::verify_mutateCoverPartially () resolve by matching, but retain an extraneous, uncovered extension.

stage::interact::test::UICoordResolver_test Member UICoordResolver_test::verify_mutateExtend () mutate given UI coordinates by uncovered extension.

stage::interact::test::UICoordResolver_test Member UICoordResolver_test::verify_queryAnchor () query anchorage of given UI coordinates.

stage::interact::test::UICoordResolver_test Member UICoordResolver_test::verify_simpleUsage () introduction to UI coordinate resolution

• use a backing "real" (dummy) data structure to resolve against
• establish a suitable implementation of the LocationQuery interface
• attach a resolver
• have fun

stage::interact::test::UILocationSolver_test Class UILocationSolver_test verify a mechanism to resolve the desired location of an UI-element.

stage::interact::test::UILocationSolver_test Member UILocationSolver_test::simple_usage_example () demonstrate the typical invocation and usage

stage::interact::test::UILocationSolver_test Member UILocationSolver_test::verify_cornerCases () cover theoretical corner cases regarding the process of location solving.

stage::interact::test::UILocationSolver_test Member UILocationSolver_test::verify_standardSituations () emulate the relevant standard situations of view location resolution.

lib::test::UniqueMallocOwner_test Class UniqueMallocOwner_test Verify automatic management of memory originally allocated by C malloc.

util::test::UtilCollection_test Class UtilCollection_test verify some convenience shortcuts and helpers dealing with Collections and sequences (Iterators).

util::test::UtilFloordiv_test Class UtilFloordiv_test Evaluate a custom built integer floor function.

util::test::UtilFloordiv_test Member UtilFloordiv_test::runPerformanceTest () timing measurements to compare implementation details.

util::test::UtilFloorwrap_test Class UtilFloorwrap_test Verify a custom built integer scale division and wrapping function.

util::test::UtilForeach_test Class UtilForeach_test Invoking an operation for each element of a collection.

util::test::UtilForeach_test Member UtilForeach_test::check_existence_quant (CO coll) verify the logic of universal and existential quantisation.

util::test::UtilForeach_test Member UtilForeach_test::check_foreach_bind (CO coll) bind additional parameters on-the-fly, including the possibility to use a placeholder to denote the position of the variable parameter

util::test::UtilForeach_test Member UtilForeach_test::check_foreach_bind_const (CO const &coll) the input sequence can be also taken from a const container (for iterators this obviously doesn't make sense

util::test::UtilForeach_test Member UtilForeach_test::check_foreach_lambda (CO coll) use lambda-expressions, to be invoked for each element

util::test::UtilForeach_test Member UtilForeach_test::check_foreach_memFun (CO coll) bind a member function to be invoked for each element

util::test::UtilForeach_test Member UtilForeach_test::check_foreach_plain (CO coll) invoke a simple free function, given as reference, function pointer or functor.

util::test::UtilForeach_test Member UtilForeach_test::check_invoke_on_each () the binding can also be used to dispatch an operation on each element within a object collection: here the parameter is used as this pointer to specify the object instance

util::test::UtilForeach_test Member UtilForeach_test::check_ref_argument_bind (CO coll) under some circumstances, it is even possible to take a ref to the data in the input sequence, or to a summation variable.

util::test::UtilForeach_test Member UtilForeach_test::check_wrapped_container_passing (VecI coll) pass the collection to be iterated in various ways

• anonymous temporary
• smart pointer
• pointer
• const&

util::test::UtilTuple_test Class UtilTuple_test verify some convenience shortcuts and helpers for interplay of tuples and iterable sequences:.

util::test::UtilTuple_test Member UtilTuple_test::verify_unpackIterator () unpack a sequence into a tuple of references, usable for structural binding.

lib::meta::test::ValueTypeBinding_test Class ValueTypeBinding_test verify result type rebinding for containers, iterators values and references.

lib::meta::test::VariadicArgumentPicker_test Class VariadicArgumentPicker_test check the basic utilities for manipulating variadic template arguments.

lib::meta::test::VariadicArgumentPicker_test Member VariadicArgumentPicker_test::check_reorderedArguments () demonstrate reordering of arguments

lib::test::Variant_test Class Variant_test cover the essential properties of Lumiera's lightweight variant record.

lib::test::VectorTransfer_test Class VectorTransfer_test growing (re-allocating) a vector with noncopyable objects, with the help of a special Allocator and a custom transfer_control operation provided by the contained objects.

lib::test::VerbFunctionDispatch_test Class VerbFunctionDispatch_test Demonstration/Concept: dispatch a specific function based on the given verbs of an embedded custom language.

lib::test::VerbFunctionDispatch_test Member VerbFunctionDispatch_test::render_verbose (VerbSeq tokens) demonstrate the dispatching based on the concrete verb token.

lib::test::VerbFunctionDispatch_test Member VerbFunctionDispatch_test::verify_dispatch (VerbSeq tokens) verify the correct individual dispatch through a computation specific for the given verb

lib::test::VerbVisitorDispatch_test Class VerbVisitorDispatch_test Demonstration/Concept: build pre-bound VerbPack objects to embody a specific operation on the "receiver" interface, then invoke them on a given concrete implementation.

lib::test::VerbVisitorDispatch_test Member VerbVisitorDispatch_test::apply_different_receivers (TokenSeq &tokens) demonstrate that another receiver indeed invokes different implementations of the Interface functions embedded within the Verb.

lib::test::VerbVisitorDispatch_test Member VerbVisitorDispatch_test::apply_VerboseRenderer (TokenSeq &tokens) demonstrate the dispatching based on the concrete verb token.

lib::test::VerbVisitorDispatch_test Member VerbVisitorDispatch_test::build_and_copy_tokens () verify the correct individual dispatch through a computation specific for the given verb

stage::model::test::ViewHook_test Class ViewHook_test verify the mechanism to attach widgets to a canvas, while keeping the canvas implementation itself opaque.

stage::model::test::ViewHook_test Member ViewHook_test::reOrderHooked () a mechanism to re-attach elements in changed order.

stage::model::test::ViewHook_test Member ViewHook_test::verify_multiplicity () each hooking has a distinct identity and is managed on its own.

stage::model::test::ViewHook_test Member ViewHook_test::verify_standardUsage () the standard use case is to hook up a widget to a canvas for display.

stage::interact::test::ViewSpecDSL_test Class ViewSpecDSL_test verify the mechanics of a functor based internal DSL to configure access and allocation patters for component views.

stage::interact::test::ViewSpecDSL_test Member ViewSpecDSL_test::verify_genericInvocation () generic integrated access through ViewLocator This test demonstrates and verifies the way ViewLocator combines type based selection of the applicable DSL clauses, the invocation of those DSL definitions, the allocation of a suitable element and finally specifically typed access to this located or allocated element.

lib::meta::test::VirtualCopySupport_test Class VirtualCopySupport_test verify a mechanism to allow for cloning and placement new of opaque, type-erased entities.

lib::meta::test::VirtualCopySupport_test Member VirtualCopySupport_test::verify_TestFixture () our test fixture is comprised of

• a common interface (#Interface)
• a implementation template #Sub to hold a buffer and manage a distinct random value at some position in that buffer, which depends on the concrete implementation type
• layered on top are adapters to make this implementation class either fully copyable, non-assignable, only movable or noncopyable.

lumiera::visitor_concept_draft::test::VisitingTool_concept Class VisitingTool_concept build and run some common cases for developing and verifying ichthyo's implementation concept for the Visitor Pattern.

lib::visitor::test1::VisitingTool_test Class VisitingTool_test our lib implementation of the visitor pattern.

lib::visitor::test2::VisitingToolExtended_test Class VisitingToolExtended_test more esoteric corner cases of our visitor lib implementation.

stage::model::test::WLink_test Class WLink_test verify proper behaviour of a smart-link to a sigc::trackable GTK widget.

stage::model::test::WLink_test Member WLink_test::verify_copy () registration state is properly handled on copy, move and swap

stage::model::test::WLink_test Member WLink_test::verify_reconnect () registration is automatically maintained when re-assigning targets

stage::model::test::WLink_test Member WLink_test::verify_standardUsage () the standard use case is to hold onto a widget owned by someone else, with automatic disconnection

vault::gear::test::WorkForce_test Class WorkForce_test WorkForce-Service: maintain a pool of active worker threads.

vault::gear::test::WorkForce_test Member WorkForce_test::simpleUsage () demonstrate simple worker pool usage

vault::gear::test::WorkForce_test Member WorkForce_test::verify_countActive () dynamically determine count of currently active workers.

vault::gear::test::WorkForce_test Member WorkForce_test::verify_defaultPool () by default, the WorkForce is initially inactive; once activated, it scales up to the number of cores reported by the runtime system.

vault::gear::test::WorkForce_test Member WorkForce_test::verify_detectError () exceptions emanating from within the worker are catched and reported by setting the isFailure argument flag of the finalHook functor invoked at worker termination.

vault::gear::test::WorkForce_test Member WorkForce_test::verify_dtor_blocks () verify that the WorkForce dtor waits for all active threads to disappear

• use a work-functor which keeps all workers blocked
• start the WorkForce within a separate thread
• in this separate thread, cause the WorkForce destructor to be called
• in the test main thread release the work-functor blocking
• at this point, all workers return, detect shutdown and terminate

vault::gear::test::WorkForce_test Member WorkForce_test::verify_finalHook () verify invocation of a thread-termination callback

vault::gear::test::WorkForce_test Member WorkForce_test::verify_pullWork () the given work-functor is invoked repeatedly, once activated.

vault::gear::test::WorkForce_test Member WorkForce_test::verify_scalePool () the number of (separate) workers can be scaled up, both stepwise and as fraction of full hardware concurrency

vault::gear::test::WorkForce_test Member WorkForce_test::verify_workerDismiss () when a worker is sent into sleep-cycles for an extended time, the worker terminates itself.

vault::gear::test::WorkForce_test Member WorkForce_test::verify_workerHalt () can cause a worker to terminate by return-value from the work-functor

vault::gear::test::WorkForce_test Member WorkForce_test::verify_workerRetard () a worker can be retarded and throttled in case of contention.

vault::gear::test::WorkForce_test Member WorkForce_test::verify_workerSleep () a worker can be sent to sleep, throttling the poll frequency.

lib::test::ZombieCheck_test Class ZombieCheck_test verify the ability to trap access to deceased objects.

stage::model::test::ZoomWindow_test Class ZoomWindow_test verify consistent handling of scrolling and zoom settings for the timeline.

stage::model::test::ZoomWindow_test Member ZoomWindow_test::safeguard_extremeOffset () verify ZoomWindow code is protected against excess scrolling.

stage::model::test::ZoomWindow_test Member ZoomWindow_test::safeguard_extremeTimePos () verify ZoomWindow code can navigate extremal time positions, thereby observing domain bounds without numeric wrap.

stage::model::test::ZoomWindow_test Member ZoomWindow_test::safeguard_extremeZoomOut () verify ZoomWindow code can handle extreme zoom-out to reveal a timeline of epic dimensions....

stage::model::test::ZoomWindow_test Member ZoomWindow_test::safeguard_poisonousMetric () verify ZoomWindow code can handle "poisonous" fractional number parameters

• toxic zoom factor passed through ZoomWindow::setMetric(Rat)
• toxic proportion factor passed to ZoomWindow::setVisiblePos(Rat)
• indirectly cause toxic posFactor in ZoomWindow::anchorWindowAtPosition(FSecs) by providing a target position very far off current window location

stage::model::test::ZoomWindow_test Member ZoomWindow_test::safeguard_reversed_intervals () verify safeguards against reversed time intervals

stage::model::test::ZoomWindow_test Member ZoomWindow_test::safeguard_toxic_zoomFactor () demonstrate sanitising of "poisonous" fractional zoom factor

• construct an example factor of roughly 2/3, but using extremely large numerator and denominator close to total time axis dimensions.

stage::model::test::ZoomWindow_test Member ZoomWindow_test::safeguard_veryDeep () verify ZoomWindow and handle extreme zoom-in.

stage::model::test::ZoomWindow_test Member ZoomWindow_test::safeguard_verySmall () verify ZoomWindow can handle excessively small windows.

stage::model::test::ZoomWindow_test Member ZoomWindow_test::safeguard_zero_init () verify safeguards against empty initialisation interval

stage::model::test::ZoomWindow_test Member ZoomWindow_test::verify_calibration () verify defining and retaining the effective extension in pixels

• changes to the extension are applied by adjusting the visible window
• visible window's start position is maintained
• unless the resulting window would exceed the overall canvas, in which case the window is shifted, retaining metrics
• however, if resulting window can not be made to fit, it is truncated to current canvas and metric is adjusted to keep overall pixel extension

stage::model::test::ZoomWindow_test Member ZoomWindow_test::verify_changeNotification () a notification-λ can be attached and will be triggered on each change

stage::model::test::ZoomWindow_test Member ZoomWindow_test::verify_metric () zoom in and out, thereby adjusting the metric

• window extension in pixels is always retained
• window is shifted when surpassing canvas bounds
• metric is adjusted to keep excess window within pixel extension
• otherwise zooming is centred around an anchor position, favouring centre

stage::model::test::ZoomWindow_test Member ZoomWindow_test::verify_scroll () sliding the visible window, possibly expanding canvas

stage::model::test::ZoomWindow_test Member ZoomWindow_test::verify_setup () verify the possible variations for initial setup of the zoom window

• can be defined either with the canvas duration, or an explicit extension given in pixels, or both
• after construction, visible window always covers whole canvas
• window extension, when given, defines the initial metric
• otherwise pixel extension is derived from default metric

stage::model::test::ZoomWindow_test Member ZoomWindow_test::verify_simpleUsage () simple usage example: double the zoom level, then scroll to the left

stage::model::test::ZoomWindow_test Member ZoomWindow_test::verify_window () position and extension of the visible window can be set explicitly