Test List

globalScope> Member TEST (adhereTo, Unit_LoadUnload)

Checks exact loading stages of objects provoked by the use of adhereTo

globalScope> Member TEST (regexMatcher, Unit_SubstituteHomeDir)

Checks if the home directory replacing works properly

globalScope> Member TEST (regexMatcher, Unit_MatchBlock)

Checks if block header matching works

globalScope> Member TEST (managedPtr, Unit_ThreeDimensionalPtr)

Tests if three dimensional managed pointers work properly

globalScope> Member TEST (managedPtr, Unit_TwoDimensionalPtr)

Tests if two dimensional managed pointers work properly

globalScope> Member TEST (managedPtr, Unit_MultipleAdhereTo)

Tests, that pointers of multiple adhereTo-s glued to the same managedPtr actually are the same

globalScope> Member TEST (managedPtr, Unit_TestReassignment)

Tests, if pointers can be copied and copied back without problems

globalScope> Member TEST (managedPtr, Unit_ShallowCopy)

Tests, that copying a managed pointer is done in a shallow way

globalScope> Member TEST (managedPtr, Unit_OverwriteWhileUsing)

Tests if a pointer can be adhereto-ed and overwritten in between

globalScope> Member TEST (managedPtr, Unit_ZeroSizedObjectsCanBeOverwrittenSavely)

Checks whether we may savely overwrite zero-sized managedPtrs

Note

run this test using valgrind to see difference

globalScope> Member TEST (managedPtr, Unit_GetSize)

Tests if the size of a data array can be properly retrieved from the managedPtr

globalScope> Member TEST (managedPtr, Unit_EmptySizeAllowed)

Tests if a pointer of size 0 can be used, e.g. for default ctors of wrapper classes

globalScope> Member TEST (managedPtr, Unit_CallDestructorIfSwapped)

Tests if class constructors and destructors are called appropriately as the hierarchy dictates

globalScope> Member TEST (managedPtr, Unit_ConcurrentUseAccessThree)

More complex scenario for concurrent access

Note

would like to assert no throw, but pragma omp is not allowd

globalScope> Member TEST (managedPtr, Unit_ConcurrentUseAccess)

Tests if concurrent access works properly while loading and unloading objects

Note

would like to assert no throw, but pragma omp is not allowd

globalScope> Member TEST (managedPtr, Unit_MultithreadingConcurrentCreateDelete)

Tests if parallel deleting of pointers work

Note

would like to assert no throw, but pragma omp is not allowd

globalScope> Member TEST (managedPtr, Integration_DirectVsSmartAccess)

Demonstrates why direct access if awfully slow in comparison to smart access via adhereto

globalScope> Member TEST (managedPtr, Unit_ZeroSizedObjects)

Tests if zero sized objects (while not usefull) can be handled

globalScope> Member TEST (managedPtr, Unit_PointerAllocation)

Tests the different constructors of managedPtr

globalScope> Member TEST (managedPtr, Unit_CreateAndInitialize)

Tests if classes can be managed properly

globalScope> Member TEST (managedPtr, Unit_DirectAccessSwapped)

Tests direct access in a more complex scenario (depcrecated since not thread safe and slow!)

globalScope> Member TEST (managedPtr, Unit_DirectAccess)

Tests direct access on a managedPtr (deprecated since not thread safe and slow!)

globalScope> Member TEST (managedPtr, Unit_DeleteWhileInUse)

Demonstrates how the application dies when a pointer is deleted while still in use

globalScope> Member TEST (managedPtr, Unit_SmartPointery)

Checks if chunk stati are appropriately set when handling different types of adhereto

globalScope> Member TEST (managedPtr, Unit_GetLocPointer)

Tests if a local pointer can be retreived or not if setUse is or is not done beforehand

globalScope> Member TEST (managedPtr, Unit_ChunkInUse)

Test manual set and unsetUse on a pointer and checks if the chunks are updated appropriately

globalScope> Member TEST (managedPtr, Unit_ParentIDs)

Tests if parent is correctly assigned for the first pointer

globalScope> Member TEST (managedPtr, Unit_NoMemoryManager)

Tests the behaviour if no memory manager is explicitely installed, ergo testing the fallback default

globalScope> Member TEST (managedMemory, DISABLED_Unit_FallbackToDefaultManagerChainWrongOrder)

Check what happens to the default manager if we delete a chain of managers in the wrong order

globalScope> Member TEST (managedMemory, Unit_FallbackToDefaultManagerChain)

Check if multiple managers are allocated and deleted (in the right order), that we can fallback to the original manager

globalScope> Member TEST (managedMemory, DISABLED_VersionInfo)

prints out a version info (git version + diff)

globalScope> Member TEST (managedMemory, Unit_BaseMemoryUsage)

Checks basic manager usage stats for consistency under resize

globalScope> Member TEST (managedMemory, Unit_DefaultManagerPresentAfterAllocation)

Checks whether we fall back to default when deleting our own memory manager instance

globalScope> Member TEST (managedMemory, Unit_DefaultManagerPresent)

Checks presence of a default manager at runtime without doing anything before

globalScope> Member TEST (managedFileSwap, Unit_EmptySizeFillsUp)

Tests what happens if a pointer of size 0 is inserted into a full memory

globalScope> Member TEST (managedFileSwap, Unit_EmptySizeSwapped)

Tests what happens if a pointer of size 0 is potentially swapped

globalScope> Member TEST (managedFileSwap, Unit_CheckSwapStats)

Tests whether swapstats are gathered correctly for some simple cases and if they are plausible for some more complicated stuff

globalScope> Member TEST (managedFileSwap, Unit_SwapPolicy)

Check correct usage of swap policy

globalScope> Member TEST (managedFileSwap, Integration_MatrixTranspose)

Implements a simple matrix transposition that has to be swapping to check for data integrity

globalScope> Member TEST (managedFileSwap, Unit_SwapNextAndSingleIsland)

Checks capability to cope with memory shortage in certain circumstances

globalScope> Member TEST (managedFileSwap, Unit_SwapSingleIsland)

Checks capability to cope with memory shortage in certain circumstances

globalScope> Member TEST (managedFileSwap, Unit_SwapAllocation)

Checks correct allocation of swap files

globalScope> Member TEST (managedFileSwap, Integration_RandomAccessVariousSize)

Puts memory manager and swap under heavy load of objects of various sizes by randomly allocating / deallocating them

globalScope> Member TEST (managedFileSwap, Integration_RandomAccess)

Puts memory manager and swap under heavy load of objects of the same size by randomly allocating / deallocating them

globalScope> Member TEST (managedFileSwap, Unit_SwapSize)

Tests whether the swap size is accounted for correctly.

globalScope> Member TEST (managedFileSwap, Unit_SimpleSwapping)

Tests interplay between managedFileSwap and a cylicManaged Memory

globalScope> Member TEST (managedFileSwap, Unit_ManualSwappingDelete)

Tests whether deletion of swapped out elements is handled correctly.

globalScope> Member TEST (managedFileSwap, Unit_ManualMultiSwapping)

Tests whether managedFileSwap can take a few memoryChunk and store it securely.

globalScope> Member TEST (managedFileSwap, Unit_ManualSwapping)

Tests whether managedFileSwap can take a memoryChunk and store it securely.

globalScope> Member TEST (managedFileSwap, Unit_LazyPffree)

Tests for speedup implied by const lazy deallocation

Note

As this is normally cached, real life speedup will be a multiple of this when writing to disk...

globalScope> Member TEST (managedDummySwap, Unit_SwapSize)

Checks if the swap size is adjusted when setUse and unsetUse are called

Note

Again for testing internals, not thought for use like this

globalScope> Member TEST (managedDummySwap, Unit_ManualSwappingDelete)

Checks if swap delete works manually

Note

Again testing internals, not for use like this

globalScope> Member TEST (managedDummySwap, Unit_ManualSwapping)

Checks if swapping works when triggered manually

Note

This is not supposed to be used by the user, just for checking internals

globalScope> Member TEST (dummyManagedMemory, Unit_ThrowsExceptions)

Checks that dummyManager starts crying when he is asked to create an object for us

globalScope> Member TEST (cyclicManagedMemory, Unit_RecoveryFromRandomAccess)

Checks recovery from random access to preemptive access

globalScope> Member TEST (cyclicManagedMemory, Unit_CleanupOfForgottenPointers)

Checks whether forgotten pointers are garbage-collected

globalScope> Member TEST (cyclicManagedMemory, Unit_HandleNestedObjects)

Checks whether nested access in class is handled correctly

globalScope> Member TEST (cyclicManagedMemory, Unit_WorkingWithSSE)

Checks whether memory alignment attributes are handled correctly

globalScope> Member TEST (cyclicManagedMemory, Unit_NotEnoughSpaceForArray)

Checks whether we detect if an array object does not fit into ram

globalScope> Member TEST (cyclicManagedMemory, Unit_NotEnoughSpaceForOneElement)

Checks whether we detect if a single object does not fit into ram

globalScope> Member TEST (cyclicManagedMemory, Unit_RandomAllocation)

Checks capability to cope with objects of random size in random allocation

globalScope> Member TEST (cyclicManagedMemory, Unit_VariousSize)

Checks capability to cope with objects of various size

globalScope> Member TEST (cyclicManagedMemory, Integration_RandomArrayAccess)

checks integrity and accessability of array objects in random access

globalScope> Member TEST (cyclicManagedMemory, Integration_ArrayAccess)

Checks integrity of data written to a large array

globalScope> Member TEST (cyclicManagedMemory, Unit_NotEnoughMemOrSwapSpace)

Checks whether we throw when there's not enough ram+swap to fullfil request

globalScope> Member TEST (cyclicManagedMemory, Unit_DeepAllocatePointers)

Checks whether we can allocate class objects and track the object hierarchy correctly

globalScope> Member TEST (cyclicManagedMemory, Unit_AllocatePointers)

Checks whether we can allocate data via memory manager

globalScope> Member TEST (configReader, Unit_IgnoreEmptyLines)

Checks if empty lines are properly ignored

globalScope> Member TEST (configReader, Unit_OverwriteDefaultInverseOrder)

Checks if a default block after the specific block does not overwrite the latter

globalScope> Member TEST (configReader, Unit_OverwriteDefault)

Checks if a binary specific block can overwrite the default block

globalScope> Member TEST (configReader, Unit_ParseProgramName)

Checks if the application name can be retreived properly

globalScope> Member TEST (configReader, Unit_DefaultOverwritesMissingVariablesLookFurther)

Checks if config variables which are missing in a specific block are overwritten by the default block even if the default block comes after the specific one

globalScope> Member TEST (configReader, Unit_DefaultOverwritesMissingVariables)

Checks if config variables which are missing in a specific block are overwritten by the default block

globalScope> Member TEST (configReader, Unit_IgnoreMissingVariables)

Checks if config variables may be missing

globalScope> Member TEST (configReader, Unit_IgnoreCommentLines)

Checks if comment lines are ignored properly

globalScope> Member TEST (configReader, Unit_ParseCustomFile)

Checks if config file in a custom path is read in properly

globalScope> Member TEST (configuration, Unit_DefaultValues)

Checks the default values of configuration options and set up of the collection

globalScope> Member TEST (configLine, Unit_SetValueMissingUnit)

Checks if values without units can be set when units are expected

globalScope> Member TEST (configLine, Unit_SetValue)

Checks if values with units for byte sizes can be set properly

globalScope> Member TEST (adhereTo, Unit_CopyCorrectness)

Checks whether adhereTo Objects are copied correctly

globalScope> Member TEST (adhereTo, Unit_MacroUsage)

Checks correct working of convenience macros

globalScope> Member TEST (adhereTo, Unit_TwiceAdhered)

Checks multithreading compatibility of adhereTo with concurrent access

globalScope> Member TEST (adhereTo, Unit_Multithreading)

Checks multithreading compatibility of adhereTo

globalScope> Member TEST (adhereTo, Unit_AccessData)

Checks whether we can access stored data

globalScope> Member TEST (adhereTo, Unit_LoadUnloadConst)

Checks exact loading stages of const objects provoked by the use of adhereTo