Lumiera  0.pre.03
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 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::check_DependencyInjection ()
usage scenario: dependency injection for tests
Member AdviceSituations_test::check_ProxyRenderingAdvice ()
usage scenario: switch a processing node into proxy mode.
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 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 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 Since this test focuses on the bus side of standard interactions, it seems indicated to emulate the complete invocation situation, which involves passing thread boundraries.
Member BusTerm_test::replayStateMark ()
replay previously captured state information" </dd> <dt>\anchor _test000216 \_setscope gui::model::test::BusTerm_test Member \_internalref classgui_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 _test000136 \_setscope proc::engine::test::CalcStream_test Class \_internalref classproc_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 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::checkArgumentComparison ()
verify the comparison operators
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 Proc-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 ProcDispatcher 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 ProcDispatcher.
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 proc::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 ProcDispatcher.
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 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::check_ContinuationBuilder ()
usually at the end of each standard invocation, after scheduling a chunk of new Jobs, an additional continuation job is created to re-invoke this scheduling step.
Member DispatcherInterface_test::verify_basicDispatch ()
perform the basic dispatch step and verify the generated frame coordinates
Member DispatcherInterface_test::verify_standardDispatcherUsage ()
the standard invocation sequence used within the engine for planning new jobs.
Class DispatcherLooper_test
verify encapsulated control logic of ProcDispatcher.
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 DummySessionConnection_test
verify scaffolding used to develop the actual connection between the UI, the UI-Bus, the core services in the UI and the Session.
Member DummySessionConnection_test::demonstrate_weakness ()
demonstrate a serious weakness of When...
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.
Member ExceptionError_test::checkErrorFlagPropagation ()
verify throwing of Exceptions based on a non-cleared C error flag
Member ExceptionError_test::checkErrorIntegration ()
by constructing an lumiera::Error object, the corresponding lumiera_error state is set automatically
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::terminateUnknown () noexcept
terminate the Application by throwing an undeclared exception.
Member ExceptionError_test::throwSpecial (string)
simply throw some exception and pass context info
Class FixtureChangeDetector_test
planned test for detecting changes in a given segmentation
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 FunctorUtil_test
verify some aspects of the functor-util's behaviour.
Member FunctorUtil_test::verifyBruteForceComparison ()
workaround for the missing functor comparison operator
Member FunctorUtil_test::verifyHashThroughBackdoor ()
workaround for missing standard hash calculation for functor objects.
Class GeneratorCombinations_test
check utilities for generating case combinations.
Class GenericIdFunction_test
cover a standard scheme to generate type and instance identifiers.
Class GenericRecordRepresentation_test
Verify properties of a special collection type meant for external representation of object-like data, especially for symbolic representation in diff messages.
Class GenNodeBasic_test
Verify properties of a special collection type shaped for external representation of object-like data.
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 HierarchyOrientationIndicator_test
describing and rebuilding a tree structure while visiting the tree in depth first order.
Member HierarchyOrientationIndicator_test::demonstrate_tree_rebuilding ()
demonstrate how a Node tree structure can be rebuilt just based on the visitation sequence of an original tree.
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 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 structures, based on the IterExplorer template.
Member IterExplorer_test::verifyBreadthFirstExploration ()
a breadth-first visiting and exploration scheme of a tree like system, built on top of the IterExplorer monad.
Member IterExplorer_test::verifyChainedIterators ()
verify a helper to chain a series of iterators into a "flat" result sequence.
Member IterExplorer_test::verifyDepthFirstExploration ()
a depth-first visiting and exploration scheme of a tree like system, built on top of the IterExplorer monad.
Member IterExplorer_test::verifyMonadOperator ()
cover the basic monad bind operator, which is used to build all the specialised Iterator flavours.
Member IterExplorer_test::verifyRawChainedIterators ()
variation of the iterator chaining facility.
Member IterExplorer_test::verifyRecursiveSelfIntegration ()
verify a variation of recursive exploration, this time to rely directly on the result set iterator type to provide the re-integration of intermediary results.
Member IterExplorer_test::verifyStateAdapter ()
demonstrate the underlying solution approach of IterExplorer.
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 IterTreeExplorer_test
use a simple source iterator yielding numbers to build various functional evaluation pipelines, based on the TreeExplorer template.
Member IterTreeExplorer_test::demonstrate_LayeredEvaluation ()
Demonstration how to build complex algorithms by layered tree expanding iteration
Member IterTreeExplorer_test::verify_asIterSource ()
package the resulting Iterator as automatically managed, polymorphic opaque entity implementing the IterSource interface.
Member IterTreeExplorer_test::verify_combinedExpandTransform ()
combine the recursion into children with a tail mapping operation.
Member IterTreeExplorer_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 IterTreeExplorer_test::verify_depthFirstExploration ()
use a preconfigured exploration scheme to expand depth-first until exhaustion.
Member IterTreeExplorer_test::verify_expand_rootCurrent ()
special feature of the Expander to lock into current child sequence.
Member IterTreeExplorer_test::verify_expandOperation ()
use a preconfigured "expand" functor to recurse into children.
Member IterTreeExplorer_test::verify_FilterChanges ()
a special filter layer which can be re-configured on the fly
Member IterTreeExplorer_test::verify_FilterIterator ()
add a filtering predicate into the pipeline.
Member IterTreeExplorer_test::verify_IterSource ()
ability to wrap and handle IterSource based iteration.
Member IterTreeExplorer_test::verify_scheduledExpansion ()
child expansion can be scheduled to happen on next iteration.
Member IterTreeExplorer_test::verify_transformOperation ()
pipe each result through a transformation function.
Member IterTreeExplorer_test::verify_wrappedIterator ()
TreeExplorer is able to wrap any Lumiera Forward Iterator
Member IterTreeExplorer_test::verify_wrappedState ()
without using any extra functionality, TreeExplorer just wraps an iterable state.
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 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 MaybeValue_test
Investigate various situations of using a Maybe value or option monad.
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 Proc-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 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 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 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 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 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 SegmentationDatastructure_test
TODO blubb
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 SessionStructureMapping_test
demonstrate the fundamental patterns to access the current session structure and contents from the GUI, and to receive a notification with the updated structure and contents.
Member SessionStructureMapping_test::retrieveSessionStructure ()
how to retrieve and enumerate session contents as operation initiated from GUI display code
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 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 setop 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 SyncClasslock_test
check proper handling of class (not instance)-based Monitor locks.
Class SyncLocking_test
create multiple threads, all concurrently trying to increment a number of counters with random steps and random pauses.
Class SyncTimedwait_test
timeout feature on condition wait as provided by pthread and accessible via the object monitor based locking/waiting mechanism.
Class SyncWaiting_test
concurrent waiting and notification, implemented via object monitor.
Class TestEventLog_test
verify a logging facility, which can be used to ensure some events happened while running test code.
Member TestEventLog_test::verify_logJoining ()
combining several logs The EventLog objects are actually just lightweight front-end handles, while the actual log lives on the Heap.
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).
Class TestGui_test
demo of writing a unit-test to execute code implemented within the UI layer.
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 ThreadLocal_test
use a wrapper to simplify handling of thread-local data.
Class ThreadWrapper_test
use the Lumiera backend to create some new threads, utilising the lumiera::Thread wrapper for binding to an arbitrary operation and passing the appropriate context.
Class ThreadWrapperJoin_test
use the Lumiera backend to create some new threads, additionally synchronising with these child threads and waiting for termination.
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.
Class TimingConstraints_test
document and verify the definition and combining of timing constraints for playback and rendering.
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
build multiple sets of type-based contexts and run a simple counting operation in each of them concurrently.
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&
Member UtilSanitizedIdentifier_test::print_clean (const string org)
print the original and the sanitised string
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 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 ZombieCheck_test
verify the ability to trap access to deceased objects.