Lumiera  0.pre.03
»edit your freedom«
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::handleEpoch ()
cover properties and handling of Epochs (low-level)
  • demonstrate that 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 _test000514 \_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 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 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")
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 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 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 the const and dereferencing variants, 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_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_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 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 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
Class LinkedElements_test
cover our custom single linked list template, in combination with Lumiera Forward Iterators and the usage of a custom allocator.
Member LinkedElements_test::verify_nonOwnership ()
add some node elements to the LinkedElements list but without taking ownership or performing any memory management.
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.
Class MakeClip_test
creating a Clip MObject and an associated Clip Asset from a given asset::Media.
Class MediaAccessMock_test
inject a Mock object replacing the backend_interface::MediaAccessFacade.
Class MementoTie_test
Verify the state capturing mechanism (memento), which is used to implement the Undo() functionality for Steam-Layer commands.
Class MetaUtils_test
verify basic type trait and metaprogramming helpers.
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.
Class MObjectInterface_test
cover the common behaviour of all MObjects.
Class MObjectRef_test
properties and behaviour of the external reference-mechanism for MObjects placed into the session.
Class MockSupport_test
validate test support for render job planning and dispatch.
Member MockSupport_test::simpleUsage ()
simple usage example of the test helpers
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
Member MockSupport_test::verify_MockJob ()
document and verify usage of a mock render job
Member MockSupport_test::verify_MockJobTicket ()
document and verify usage of a mock JobTicket for frame dispatch
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.
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
Class ModelPortRegistry_test
create a standalone model port registry to verify the behaviour of model ports, accessed through reference handles.
Class MultiFact_test
verify the basic usage patterns of the configurable factory template.
Class MultiFactArgument_test
define a MultiFact (factory with dynamic registration), which accepts additional arguments and passes them through to the registered factory function(s).
Class MultiFactSingleton_test
verify the use of the MultiFact template to access Singletons.
Class MutationMessage_test
properties of a container to transport a diff from an abstracted source generator to an abstracted consumer.
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
Member MutationMessage_test::demonstrate_treeApplication ()
use MutationMessage to transport and apply changes to target data
Class NodeBasic_test
basic render node properties and behaviour.
Class NodeFabrication_test
creating and wiring various kinds of render nodes.
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.
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
Member NodeGraphAttachment_test::fabricate_MockExitNode ()
setup a properly structured ExitNode graph using the specification scheme supported by MockSegmentation
Class NodeOperation_test
check render node operation modes and collaboration.
Class NodeSource_test
the source reading render node.
Class NullValue_test
Access "NIL values" just by type, verify these are actually singletons and are indeed created on demand.
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.
Member OpaqueHolder_test::checkHandling (TestList &objs)
cover the basic situations of object handling, especially copy operations and re-assignments
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()

Class OpaqueUncheckedBuffer_test
use an inline buffer to place objects of a subclass, without any checks.
Class OptionalRef_test
verify a reference-like wrapper class, used to provide a switchable link to an already existing object.
Class OrderingOfAssets_test
validate the equality and order relations of Asset::Ident and Asset objects.
Class OutputMapping_test
create a synthetic / example mapping to verify generic mapping behaviour.
Class OutputSlotProtocol_test
verify the OutputSlot interface and base implementation by performing full data exchange cycle.
Class PathArray_test
verify abstraction wrapper to handle some char pointers in the way of a standard sequence container with iteration and range checks.
Member PathArray_test::verify_boundaries ()
cover some tricky corner cases of the bound checks and normalisation routine.
Member PathArray_test::verify_comparisons ()
verify equality comparison Equality of PathArray is based on overall size, position and normalised content.
Class PlacementBasic_test
basic behaviour of Placements and access to MObjects.
Class PlacementHierarchy_test
creating placements specifically typed, forming an hierarchy of placement types which loosely mirrors the hierarchy of the pointee types.
Class PlacementIndex_test
basic behaviour of the index mechanism used to keep track of individual Placements as added to the current Session.
Member PlacementIndex_test::checkContentsEnumeration (Idx index)
drill down into the tree-like structure and enumerate the contents of each element, if any
Class PlacementIndexQuery_test
accessing the PlacementIndex through the generic query interface, for discovering scope contents and containing scope.
Class PlacementObjectIdentity_test
verify correct handling of object identity.
Class PlacementRef_test
properties and behaviour of the reference-mechanism for Placements.
Class PlacementScope_test
basic behaviour of the nested placement search scopes.
Member PlacementScope_test::verifyEquality ()
equality of scopes is based on the ID of the scope top (Placement)
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
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.
Class PolymorphicValue_test
build a bunch of PolymorphicValue objects.
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.
Class QuantiserBasics_test
cover the basic Quantiser API.
Class QueryFocus_test
handling of current query focus when navigating a system of nested scopes.
Member QueryFocus_test::checkNavigation (QueryFocus &focus)
move the current focus to different locations and discover contents there.
Member QueryFocus_test::manipulate_subFocus ()
side-effect free manipulation of a sub-focus, while the original focus is pushed aside (stack)
Class QueryFocusStack_test
behaviour of the stack of focus location paths.
Class QueryResolver_test
verify the mechanism for issuing typed queries through a generic interface, without disclosing the facility actually answering those queries.
Class QueryText_test
cover basic properties of the generic syntactical query representation.
Class QueryUtils_test
check the various small helpers and utilities we utilise for dealing with ConfigQuery
Member QueryUtils_test::check_countPred ()
counting of predicates in a query (currently 4/08 regexp based...)
Member QueryUtils_test::check_extractID ()
the simple regexp extracting a parameter token
Member QueryUtils_test::check_normaliseID ()
sanitising and normalising various tokens
Member QueryUtils_test::check_removeTerm ()
the regexp based cutting of a term with given symbol
Class Rational_test
cover some aspects of working with fractional numbers.
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.
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
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
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
Class RebuildFixture_test
(re)building the ExplicitPlacement objects from the objects placed into the Session/Model.
Class RefArray_test
build several wrappers, each based on a different storage, all providing RefArray access to a given vector.
Member RemoveFromSet_test::test_remove (string elems_to_remove)
populate a test set, remove the denoted elements and print the result...
Class RenderSegment_test
create a render process from a given segment of the Session.
Class ReplaceableItem_test
scrutinise an adapter to snapshot non-assignable values.
Member ReplaceableItem_test::verifyNonComparableElements ()
verify we can handle elements without comparison operator
Member ReplaceableItem_test::verifyOnlyMoveConstructible ()
handle elements that allow nothing but move construction
Member ReplaceableItem_test::verifySaneInstanceHandling ()
verify that ctor and dtor calls are balanced, even when assigning and self-assigning.
Member ReplaceableItem_test::verifyWrappedPtr ()
verify especially that we can handle and re-"assign" an embedded pointer
Class Result_test
Verify an intermediary »Either« type, to embody either a successful result, or document a failure with encountered exception.
Class SchedulerActivity_test
verify behaviour of the Scheduler Activity Language.
Member SchedulerActivity_test::dispatchChain ()
verify the ability to dispatch and perform a chain of activities.
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
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
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
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
Member SchedulerActivity_test::simpleUsage ()
demonstrate simple Activity usage
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
Member SchedulerActivity_test::verifyActivity_Gate_block ()
behaviour of Activity::GATE: the count-down condition determines if activation passes or will spin around for later re-try
Member SchedulerActivity_test::verifyActivity_Gate_dead ()
behaviour of Activity::GATE: the rest of the chain is just skipped in case of deadline violation
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, but also re-schedules a further check into the future
  • when receiving a notification, the latch is decremented
  • if this causes the Gate to open, the chain is immediately scheduled for activation, but the Gate also locked forever
  • neither a further activation, nor a further notification has any effect after this point...
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
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
Member SchedulerActivity_test::verifyActivity_Notify_activate ()
behaviour of Activity::NOTIFY when activated
  • notification is dispatched as special message to an indicated target Activity
  • when activated, a NOTIFY-Activity posts itself through the Execution Context hook
  • this way, further processing will happen in management mode (single threaded)
Member SchedulerActivity_test::verifyActivity_Notify_dispatch ()
behaviour of Activity::NOTIFY when activation leads to a dispatch
  • when posting a NOTIFY, a dedicated notification function is invoked on the chain
  • what actually happens then depends on the receiver; here we just activate a test-Tap
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
Class SchedulerCommutator_test
Scheduler Layer-2: coordination of Activity execution.
Member SchedulerCommutator_test::demonstrateSimpleUsage ()
demonstrate a simple usage scenario
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
Member SchedulerCommutator_test::torture_GroomingToken ()
ensure the GroomingToken mechanism indeed creates mutual exclusion to protected against concurrent corruption.
Member SchedulerCommutator_test::verify_DispatchDecision ()
verify the logic to decide where and when to perform the dispatch of a Scheduler Activity chain.
Member SchedulerCommutator_test::verify_findWork ()
verify logic of queue updates and work prioritisation.
Member SchedulerCommutator_test::verify_GroomingToken ()
verify logic to control concurrent execution
Member SchedulerCommutator_test::verify_postDispatch ()
verify entrance point for performing an Activity chain.
Class SchedulerInterface_test
verify and demonstrate the organisation of the high-level interface for defining jobs to be invoked by the scheduler.
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"
Class SchedulerInvocation_test
Scheduler Layer-1: queue processing and invocation by priority.
Member SchedulerInvocation_test::simpleUsage ()
demonstrate a simple usage scenario of data passing
Member SchedulerInvocation_test::verify_isDue ()
the entry appearing at head is due when its time is at or before current time.
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
Member SchedulerInvocation_test::verify_stability ()
sort order is not necessarily stable if using identical time specs on entrance
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
Class SchedulerLoadControl_test
verify behaviour patterns relevant for Scheduler load control.
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
Member SchedulerLoadControl_test::classifyHorizon ()
verify classification of time horizon for scheduling.
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.
Member SchedulerLoadControl_test::simpleUsage ()
TODO demonstrate a simple usage scenario
Member SchedulerLoadControl_test::tendNextActivity ()
verify the mark for tended next head Activity.
Member SchedulerLoadControl_test::walkingDeadline ()
TODO
Class SchedulerService_test
Scheduler component integration test: add and process dependent jobs.
Member SchedulerService_test::setupLalup ()
TODO
Member SchedulerService_test::simpleUsage ()
TODO demonstrate a simple usage scenario
Member SchedulerService_test::walkingDeadline ()
TODO
Class SchedulerStress_test
Investigate and verify non-functional characteristics of the Scheduler.
Member SchedulerStress_test::setupLalup ()
TODO
Member SchedulerStress_test::simpleUsage ()
TODO demonstrate a simple usage scenario
Member SchedulerStress_test::walkingDeadline ()
TODO
Class SchedulerUsage_test
Ensure expected Scheduler functionality in standard usage situations.
Member SchedulerUsage_test::setupLalup ()
TODO
Member SchedulerUsage_test::simpleUsage ()
TODO demonstrate a simple usage scenario
Member SchedulerUsage_test::walkingDeadline ()
TODO
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.
Member ScopedCollection_test::building_RAII_Style ()
using the ScopedCollection according to the RAII pattern.
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.
Member ScopedCollection_test::verify_defaultPopulator ()
for using ScopedCollection in RAII style, several pre-defined "populators" are provided.
Member ScopedCollection_test::verify_embeddedCollection ()
simulate the typical situation of a manager owning some embedded components.
Class ScopedHolder_test
ScopedHolder and ScopedPtrHolder are initially empty and copyable.
Member ScopedHolder_test::checkSTLContainer ()
collection of noncopyable objects maintained within a STL map
Class ScopedHolderTransfer_test
growing a vector containing noncopyable objects wrapped into ScopedHolder instances.
Class ScopedPtrVect_test
ScopedPtrVect manages the lifecycle of a number of objects.
Class ScopePath_test
properties and behaviour of the path of nested scopes.
Member ScopePath_test::check_RefcountProtection (PMO &refPlacement)
the embedded refcount is handled sensibly when it comes to copying.
Member ScopePath_test::navigate (const ScopePath refPath, PPIdx index)
modify a path by navigating it.
Class ScopeQuery_test
how to discover contents or location of a container-like part of the high-level model.
Class SearchPathSplitter_test
verify splitting a search path specification and retrieving the components by iteration.
Class SegmentationIntegration_test
Properties and behaviour of a complete Segmentation data structure.
Class SessionCommandFunction_test
verify integrated functionality of command dispatch through the SessionCommand facade.
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
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
Member SessionCommandFunction_test::perform_simpleInvocation ()
demonstrate a simple direct invocation
Member SessionCommandFunction_test::startDispatcher ()
start the session loop thread, similar to what the »session subsystem« does
Member SessionCommandFunction_test::stopDispatcher ()
verify the »session loop thread« has finished properly
Class SessionElementQuery_test
cover the part of the session API allowing to retrieve specific elements by query.
Class SessionElementTracker_test
verify the tracking of special session/model elements, to be exposed through an self-contained interface module on the session API.
Member SessionElementTracker_test::verify_cleanup (PTimeline const &aTimeline_in_session)
ensure the asset cleanup doesn't interfere with session shutdown
Member SessionManager_test::clearSession ()
clear current session contents without resetting global session config.
Member SessionManager_test::getCurrentSession ()
accessing the current (global) session
Member SessionManager_test::loadMockSession ()
use a mock session serialiser to load a preconfigured test session.
Member SessionManager_test::loadSession (const string &src)
load serialised session using the real session serialiser implementation.
Member SessionManager_test::resetSession ()
reset global session config and start with a pristine default session.
Member SessionManager_test::saveSession (string &dest)
serialise (save) the current session
Class SessionModifyParts_test
perform the most important structural modifications on a session and verify they're carried out properly.
Member SessionServiceAccess_test::access_defaultSession ()
accessing an non-existing session causes creation of a new TSessionImpl instance.
Member SessionServiceAccess_test::invoke_implServices ()
accessing implementation-level APIs
Member SessionServiceAccess_test::make_newSession ()
invoking the management API to close the session.
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.
Class SimpleAllocator_test
cover the basic operations of a custom allocator, delegating to mpool.
Class Singleton_test
implement a Singleton class using our Singleton Template.
Class SingletonSubclass_test
specific dependency-injection setup, to create a singleton subclass (implementation class) instance, without coupling the caller to the concrete type.
Class SingletonTestMock_test
inject a Mock object into the Singleton Factory, to be returned and used in place of the original object.
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.
Member SplitSplice_test::demonstrate_usage ()
demonstrate how to use the »Split-Splice« algorithm with custom data
Member SplitSplice_test::verify_cornerCases ()
cover special and boundary cases
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
Member SplitSplice_test::verify_standardCases ()
cover all possible cases of splicing an interval
Member SplitSplice_test::verify_testFixture ()
verify the fixture and self-diagnostics for this test
Class StateMapGroupingStorage_test
verify the storage structure for capturing UI state works as intended.
Class StreamTypeBasics_test
check the basic workings of the stream type handling.
Class StreamTypeLifecycle_test
check the stream type registration lifecycle.
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
Member StreamTypeLifecycle_test::register_additional_TypeInfo ()
use the stream type manager to register additional type info and verify it is used in type resolution.
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
Class SubsystemRunner_test
managing start and stop of several dependent "subsystems" under various conditions.
Class Symbol_test
properties of Symbol data type.
Member Symbol_test::use_as_map_key ()
use Literal and Symbol as keys in a tree map.
Class SymbolHashtable_test
build a hashtable using Symbol objects as Keys.
Class SyncBarrier_test
verify N-fold synchronisation points by multi-thread loat-test.
Class SyncBarrierPerformance_test
investigate performance of N-fold thread synchronisation.
Member SyncBarrierPerformance_test::run (Arg)
performance investigation of N-fold synchronisation barrier
Class SyncClasslock_test
check proper handling of class (not instance)-based Monitor locks.
Class SyncLocking_test
verify the object monitor provides locking and to prevent data corruption on concurrent modification of shared storage.
Class SyncTimedwait_test
timeout feature on condition wait as provided by the underlying implementation and accessible via the object monitor based locking/waiting mechanism.
Class SyncWaiting_test
concurrent waiting and notification, implemented via object monitor.
Class TestFrame_test
verify test helper for engine tests: a dummy data frame.
Member TestFrame_test::useFrameTable ()
the table of test frames computed on demand
Member TestFrame_test::verifyFrameSeries ()
build sequences of test frames, organised into multiple families (channels).
Member TestHelper_test::checkThrowChecker ()
check the VERIFY_ERROR macro, which ensures a given error is raised.
Member TestHelper_test::checkTypeDisplay ()
prints "sizeof()" including some type name.
Class TestHelperVariadic_test
document usage of the diagnostics helper for variadic templates.
Class TestOption_test
for test::TestOption, parsing of commandline options
Member TestOption_test::doIt (const string cmdline)
performs the actual test for the option parser test::TestOption
Class ThreadWrapper_test
use the lib::Thread wrapper for simplified definition of the thread-function, argument binding and starting of threads.
Member ThreadWrapper_test::demonstrateSimpleUsage ()
demonstrate simple usage of the thread-wrapper a λ-binding
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).
Class ThreadWrapperAutonomous_test
a variation of the Thread wrapper to launch a detached thread, with automatic memory management for the thread-object..
Member ThreadWrapperAutonomous_test::demonstrateSimpleUsage ()
demonstrate simply launching a λ-function into background
Member ThreadWrapperAutonomous_test::verifyMemoryManagement ()
verify the detached thread autonomously manages its memory.
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.
Class ThreadWrapperLifecycle_test
verify lifecycle behaviour of threads managed by thread-wrapper.
Member ThreadWrapperLifecycle_test::defaultWrapperLifecycle ()
demonstrate terms of lifecycle for the default case
Member ThreadWrapperLifecycle_test::demonstrateExplicitThreadLifecycle ()
verify a special setup to start a thread explicitly and to track the thread's lifecycle state.
Member ThreadWrapperLifecycle_test::verifyThreadLifecycleHooks ()
attach user provided callback hooks to the thread lifecycle.
Class ThreadWrapperSelfRecognitionTest_test
verify the ability of a thread to detect code executing within the thread itself.
Class TimeBasics_test
sanity check of basic Time handling.
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.
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.
Class TimeFormats_test
verify handling of grid aligned timecode values.
Member TimeFormats_test::checkSmpte ()
detailed coverage of SMPTE timecode representation.
Member TimeFormats_test::checkTimecodeUsageCycle ()
demonstrate a full usage cycle of timecode and time values.
Class TimeGridBasics_test
build some simple time grids and verify their behaviour for quantising (grid aligning) time values.
Class TimelineSequenceHandling_test
verify retrieval and instance management of the top level facade objects as integrated with the session and high-level model.
Class TimeMutation_test
cover all basic cases for mutating a time specification.
Class TimeParsing_test
parse textual time specifications given in the supported timecode formats
Class TimeQuantisation_test
verify handling of quantised time values.
Class TimeValue_test
verify handling of time values, time intervals.
Member TimeValue_test::checkBasicTimeValues (TimeValue org)
creating some time values and performing trivial comparisons.
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.
Member TimeValue_test::checkTimeConvenience (TimeValue org)
additional convenience shortcuts supported especially by the canonical Time values.
Member TimeValue_test::checkTimeHash (TimeValue org)
calculate a generic hash value from a time spec
Class TimingConstraints_test
document and verify the definition and combining of timing constraints for playback and rendering.
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.
Member Timings_test::verify_next_startPoint ()
detect boundaries of frame planning chunks for arbitrary chunk duration.
Member Timings_test::verify_simpleFrameStep ()
perform the basic dispatch step and verify the generated frame coordinates
Class TrackingHeapBlockProvider_test
verify a test support facility, used to write mock components to test the lumiera engine.
Class TreeMutator_test
Demonstrate a customisable component for flexible bindings to enable generic tree changing and mutating operations to arbitrary hierarchical data structures.
Class TreeMutatorBinding_test
Building blocks to map generic changes to arbitrary private data structures.
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.
Member TreeMutatorBinding_test::mutateCollection ()
map mutation primitives onto a STL collection managed locally.
Member TreeMutatorBinding_test::mutateDummy ()
diagnostic binding: how to monitor and verify the mutations applied
Member TreeMutatorBinding_test::mutateGenNode ()
apply mutation primitives to a GenNode tree.
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
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
Class TupleRecordInit_test
Metaprogramming: how to unload the contents of a runtime typed variant sequence into ctor arguments of a (compile time typed) tuple.
Class TypedAllocationManager_test
cover the basic implementation of a custom allocator, delegating to mpool.
Class TypedCounter_test
verify the TypedCounter, which allows to maintain a counter-per-type.
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.
Class TypeDemangling_test
verify the demangling of C++ names, as available through the GCC platform ABI.
Class TypedFamilyMemberID_test
simplistic unit test to demonstrate generating _member IDs within a family of objects delineated by type.
Class TypedID_test
outline of an instance registration and accounting service.
Class TypeDisplay_test
verify post processing of demangled C++ type names.
Class TypeList_test
try out Loki-style typelist metaprogramming.
Class TypeListGenerator_test
check the helpers for dealing with lists-of-types.
Class TypeListManip_test
check utilities for manipulating lists-of-types.
Class TypeListUtil_test
verify the simple helpers for working with lists-of-types.
Class TypeSeqManipl_test
check the basic utilities for manipulating (fixed) type sequences.
Class UICoord_test
verify the basic properties of topological UI coordinate specifications.
Class UICoordResolver_test
verify query and mutation of UICoord in relation to actual UI topology.
Member UICoordResolver_test::verify_backingQuery ()
verify the command-and-query interface backing the resolver.
Member UICoordResolver_test::verify_mutateAnchor ()
mutate given UI coordinates by anchoring them.
Member UICoordResolver_test::verify_mutateCoverage ()
path matching algorithm to resolve UI coordinates with wildcards against the current UI structure tree.
Member UICoordResolver_test::verify_mutateCoverPartially ()
resolve by matching, but retain an extraneous, uncovered extension.
Member UICoordResolver_test::verify_mutateExtend ()
mutate given UI coordinates by uncovered extension.
Member UICoordResolver_test::verify_queryAnchor ()
query anchorage of given UI coordinates.
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
Class UILocationSolver_test
verify a mechanism to resolve the desired location of an UI-element.
Member UILocationSolver_test::simple_usage_example ()
demonstrate the typical invocation and usage
Member UILocationSolver_test::verify_cornerCases ()
cover theoretical corner cases regarding the process of location solving.
Member UILocationSolver_test::verify_standardSituations ()
emulate the relevant standard situations of view location resolution.
Class UniqueMallocOwner_test
Verify automatic management of memory originally allocated by C malloc.
Class UtilCollection_test
verify some convenience shortcuts and helpers dealing with Collections and sequences (Iterators).
Class UtilFloordiv_test
Evaluate a custom built integer floor function.
Member UtilFloordiv_test::runPerformanceTest ()
timing measurements to compare implementation details.
Class UtilFloorwrap_test
Verify a custom built integer scale division and wrapping function.
Class UtilForeach_test
Invoking an operation for each element of a collection.
Member UtilForeach_test::check_existence_quant (CO coll)
verify the logic of universal and existential quantisation.
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
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
Member UtilForeach_test::check_foreach_lambda (CO coll)
use lambda-expressions, to be invoked for each element
Member UtilForeach_test::check_foreach_memFun (CO coll)
bind a member function to be invoked for each element
Member UtilForeach_test::check_foreach_plain (CO coll)
invoke a simple free function, given as reference, function pointer or functor.
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
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.
Member UtilForeach_test::check_wrapped_container_passing (VecI coll)
pass the collection to be iterated in various ways
  • anonymous temporary
  • smart pointer
  • pointer
  • const&
Class UtilTuple_test
verify some convenience shortcuts and helpers for interplay of tuples and iterable sequences:.
Member UtilTuple_test::verify_unpackIterator ()
unpack a sequence into a tuple of references, usable for structural binding.
Class ValueTypeBinding_test
verify result type rebinding for containers, iterators values and references.
Class VariadicArgumentPicker_test
check the basic utilities for manipulating variadic template arguments.
Member VariadicArgumentPicker_test::check_reorderedArguments ()
demonstrate reordering of arguments
Class Variant_test
cover the essential properties of Lumiera's lightweight variant record.
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.
Class VerbFunctionDispatch_test
Demonstration/Concept: dispatch a specific function based on the given verbs of an embedded custom language.
Member VerbFunctionDispatch_test::render_verbose (VerbSeq tokens)
demonstrate the dispatching based on the concrete verb token.
Member VerbFunctionDispatch_test::verify_dispatch (VerbSeq tokens)
verify the correct individual dispatch through a computation specific for the given verb
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.
Member VerbVisitorDispatch_test::apply_different_receivers (TokenSeq &tokens)
demonstrate that another receiver indeed invokes different implementations of the Interface functions embedded within the Verb.
Member VerbVisitorDispatch_test::apply_VerboseRenderer (TokenSeq &tokens)
demonstrate the dispatching based on the concrete verb token.
Member VerbVisitorDispatch_test::build_and_copy_tokens ()
verify the correct individual dispatch through a computation specific for the given verb
Class ViewHook_test
verify the mechanism to attach widgets to a canvas, while keeping the canvas implementation itself opaque.
Member ViewHook_test::reOrderHooked ()
a mechanism to re-attach elements in changed order.
Member ViewHook_test::verify_multiplicity ()
each hooking has a distinct identity and is managed on its own.
Member ViewHook_test::verify_standardUsage ()
the standard use case is to hook up a widget to a canvas for display.
Class ViewSpecDSL_test
verify the mechanics of a functor based internal DSL to configure access and allocation patters for component views.
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.
Class VirtualCopySupport_test
verify a mechanism to allow for cloning and placement new of opaque, type-erased entities.
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.
Class VisitingTool_concept
build and run some common cases for developing and verifying ichthyo's implementation concept for the Visitor Pattern.
Class VisitingTool_test
our lib implementation of the visitor pattern.
Class VisitingToolExtended_test
more esoteric corner cases of our visitor lib implementation.
Class WLink_test
verify proper behaviour of a smart-link to a sigc::trackable GTK widget.
Member WLink_test::verify_copy ()
registration state is properly handled on copy, move and swap
Member WLink_test::verify_reconnect ()
registration is automatically maintained when re-assigning targets
Member WLink_test::verify_standardUsage ()
the standard use case is to hold onto a widget owned by someone else, with automatic disconnection
Class WorkForce_test
WorkForce-Service: maintain a pool of active worker threads.
Member WorkForce_test::simpleUsage ()
demonstrate simple worker pool usage
Member WorkForce_test::verify_countActive ()
dynamically determine count of currently active workers.
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.
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.
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
Member WorkForce_test::verify_finalHook ()
verify invocation of a thread-termination callback
Member WorkForce_test::verify_pullWork ()
the given work-functor is invoked repeatedly, once activated.
Member WorkForce_test::verify_scalePool ()
the number of (separate) workers can be scaled up, both stepwise and as fraction of full hardware concurrency
Member WorkForce_test::verify_workerDismiss ()
when a worker is sent into sleep-cycles for an extended time, the worker terminates itself.
Member WorkForce_test::verify_workerHalt ()
can cause a worker to terminate by return-value from the work-functor
Member WorkForce_test::verify_workerSleep ()
a worker can be sent to sleep, throttling the poll frequency.
Class ZombieCheck_test
verify the ability to trap access to deceased objects.
Class ZoomWindow_test
verify consistent handling of scrolling and zoom settings for the timeline.
Member ZoomWindow_test::safeguard_extremeOffset ()
verify ZoomWindow code is protected against excess scrolling.
Member ZoomWindow_test::safeguard_extremeTimePos ()
verify ZoomWindow code can navigate extremal time positions, thereby observing domain bounds without numeric wrap.
Member ZoomWindow_test::safeguard_extremeZoomOut ()
verify ZoomWindow code can handle extreme zoom-out to reveal a timeline of epic dimensions....
Member ZoomWindow_test::safeguard_poisonousMetric ()
verify ZoomWindow code can handle "poisonous" fractional number parameters
Member ZoomWindow_test::safeguard_reversed_intervals ()
verify safeguards against reversed time intervals
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.
Member ZoomWindow_test::safeguard_veryDeep ()
verify ZoomWindow and handle extreme zoom-in.
Member ZoomWindow_test::safeguard_verySmall ()
verify ZoomWindow can handle excessively small windows.
Member ZoomWindow_test::safeguard_zero_init ()
verify safeguards against empty initialisation interval
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
Member ZoomWindow_test::verify_changeNotification ()
a notification-λ can be attached and will be triggered on each change
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
Member ZoomWindow_test::verify_scroll ()
sliding the visible window, possibly expanding canvas
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
Member ZoomWindow_test::verify_simpleUsage ()
simple usage example: double the zoom level, then scroll to the left
Member ZoomWindow_test::verify_window ()
position and extension of the visible window can be set explicitly