Description

Testing utilities namespace.

This namespace contains utilities for writing unit tests, mostly from the Testing Utilities (testutils) module.

Classes
class	AnalysisDataTestInputPointSet
	Represents a single set of points in AnalysisDataTestInputFrame structure. More...

class	AnalysisDataTestInputFrame
	Represents a single frame in AnalysisDataTestInput structure. More...

class	AnalysisDataTestInput
	Represents static input data for AbstractAnalysisData tests. More...

class	AnalysisDataTestFixture
	Test fixture for AbstractAnalysisData testing. More...

class	AllocatorTest
	Templated test fixture. More...

class	CommandLine
	Helper class for tests that need to construct command lines. More...

class	CommandLineTestHelper
	Helper class for tests that construct command lines that need to reference existing files. More...

class	CommandLineTestBase
	Test fixture for tests that call a single command-line program with input/output files. More...

class	ConfMatch
	Match the contents as an gro file. More...

class	IFileMatcher
	Represents a file matcher, matching file contents against reference (or other) data. More...

class	IFileMatcherSettings
	Represents a factory for creating a file matcher. More...

class	TextFileMatch
	Use a ITextBlockMatcher for matching the contents. More...

class	NoContentsMatch
	Do not check the contents of the file. More...

class	InteractiveTestHelper
	Helper class for testing interactive sessions. More...

class	LoggerTestHelper
	Helper class for tests to check output written to a logger. More...

class	TestReferenceChecker
	Handles comparison to test reference data. More...

class	TestReferenceData
	Handles creation of and comparison to test reference data. More...

class	StdioTestHelper
	Helper class for tests where code reads directly from `stdin`. More...

class	StringTestBase
	Test fixture for tests that check string formatting. More...

class	FloatingPointDifference
	Computes and represents a floating-point difference value. More...

class	FloatingPointTolerance
	Specifies a floating-point comparison tolerance and checks whether a difference is within the tolerance. More...

class	TestException
	Exception class for reporting errors in tests. More...

class	TestFileManager
	Helper for tests that need input and output files. More...

class	TestFileInputRedirector
	In-memory implementation for IFileInputRedirector for tests. More...

class	TestFileOutputRedirector
	In-memory implementation of IFileOutputRedirector for tests. More...

class	TestOptionsProvider
	Provides additional options for the test executable. More...

class	ITextBlockMatcher
	Represents a text matcher, matching text stream contents against reference data. More...

class	ITextBlockMatcherSettings
	Represents a factory for creating a text matcher. More...

class	ExactTextMatch
	Use an exact text match (the contents should be exactly equal). More...

class	NoTextMatch
	Do not match the text (the contents are ignored). More...

class	FilteringExactTextMatch
	Use an exact text match after scrubbing lines of the text that match the supplied regular expressions. More...

class	XvgMatch
	Match the contents as an xvg file. More...

Typedefs
typedef std::shared_ptr < MockAnalysisDataModule >	MockAnalysisDataModulePointer
	Smart pointer to manage an MockAnalysisDataModule object.

typedef std::tuple< int, int, BiasParams::DisableUpdateSkips >	BiasTestParameters
	Convenience typedef: growth type enum, potential type enum, disable update skips.

typedef gmx::unique_cptr < gmx_pme_t, gmx_pme_destroy >	PmeSafePointer
	A safe pointer type for PME.

typedef ArrayRef< const real >	ChargesVector
	Charges.

typedef std::vector< RVec >	CoordinatesVector
	Coordinates.

typedef ArrayRef< RVec >	ForcesVector
	Forces.

typedef ArrayRef< const IVec >	GridLineIndicesVector
	Gridline indices.

typedef ArrayRef< const real >	SplineParamsDimVector
	Spline parameters (theta or dtheta). A reference to a single dimension's spline data; this means (atomCount * pmeOrder) values or derivatives.

typedef std::array < SplineParamsDimVector, 3 >	SplineParamsVector
	Spline parameters (theta or dtheta) in all 3 dimensions.

template<typename ValueType >
using	SparseGridValuesInput = std::map< IVec, ValueType >
	Non-zero grid values for test input; keys are 3d indices (IVec)

typedef SparseGridValuesInput < real >	SparseRealGridValuesInput
	Non-zero real grid values.

typedef SparseGridValuesInput < t_complex >	SparseComplexGridValuesInput
	Non-zero complex grid values.

template<typename ValueType >
using	SparseGridValuesOutput = std::map< std::string, ValueType >
	Non-zero grid values for test output; keys are string representations of the cells' 3d indices (IVec); this allows for better sorting.

typedef SparseGridValuesOutput < real >	SparseRealGridValuesOutput
	Non-zero real grid values.

typedef SparseGridValuesOutput < t_complex >	SparseComplexGridValuesOutput
	Non-zero complex grid values.

typedef std::array< real, 3 *3 >	Matrix3x3
	TODO: make proper C++ matrix for the whole Gromacs, get rid of this.

typedef std::vector < std::unique_ptr < TestHardwareContext > >	TestHardwareContexts
	A container of handles to hardware contexts.

typedef ::testing::Types < int32_t, real, RVec, test::MoveOnly >	TestTypes
	The types used in testing of all operations.

using	TestTypesCopyable = ::testing::Types< int32_t, real, RVec >
	The types used in testing minus move only types.

template<typename T >
using	HostAllocatorTestCopyable = HostAllocatorTest< T >
	Typed test fixture for tests requiring a copyable type.

using	AllocatorTypesToTest = ::testing::Types< HostAllocator< real >, HostAllocator< int32_t >, HostAllocator< RVec >, HostAllocator< MoveOnly > >
	Declare allocator types to test.

using	Implementations = ::testing::Types< std::allocator< int32_t >, std::allocator< float >, std::allocator< double >, std::allocator< BasicVector< float >>, std::allocator< BasicVector< double >>, AlignedAllocator< int32_t >, AlignedAllocator< float >, AlignedAllocator< double >, AlignedAllocator< BasicVector< float >>, AlignedAllocator< BasicVector< double >> >
	The types used in testing.

typedef std::tuple< int, bool, bool, bool >	SettleTestParameters
	Convenience typedef.

using	EnergyTolerances = std::unordered_map< std::string, FloatingPointTolerance >
	Convenience type.

typedef std::unique_ptr < EnergyFrameReader >	EnergyFrameReaderPtr
	Convenience smart pointer typedef.

typedef unique_cptr< ener_file, done_ener_file >	ener_file_ptr
	Convenience smart pointer typedef.

typedef unique_cptr < t_enxframe, done_enxframe >	enxframe_ptr
	Convenience smart pointer typedef.

typedef gmx::test::ImdTestFixture	ImdTest
	Test fixture for mdrun with IMD settings.

typedef MultiSimTest	MultiSimTerminationTest
	Convenience typedef.

typedef std::unique_ptr < CommandLine >	CommandLinePointer
	Convenience typedef.

typedef MultiSimTest	ReplicaExchangeEnsembleTest
	Convenience typedef.

typedef MultiSimTest	ReplicaExchangeTerminationTest
	Convenience typedef.

using	MdpFieldValues = std::map< std::string, std::string >
	Helper typedef.

typedef gmx::test::SwapTestFixture	CompelTest
	Test fixture for mdrun with "Computational Electrophysiology" settings,.

typedef MdrunTestFixture	MdrunTerminationTest
	Convenience typedef.

typedef unique_cptr < gmx_output_env_t, output_env_done >	oenv_ptr
	Convenience smart pointer typedef.

typedef unique_cptr < t_trxstatus, close_trx >	trxstatus_file_ptr
	Convenience smart pointer typedef.

typedef unique_cptr < t_trxframe, done_trxframe >	trxframe_ptr
	Convenience smart pointer typedef.

typedef std::unique_ptr < IFileMatcher >	FileMatcherPointer
	Smart pointer for managing a IFileMatcher.

typedef std::unique_ptr < ITextBlockMatcher >	TextBlockMatcherPointer
	Smart pointer for managing a ITextBlockMatcher.

Enumerations
enum	PmeSolveAlgorithm { Coulomb, LennardJones }
	PME solver type.

enum	CodePath { CPU, GPU }
	Hardware code path being tested.

enum	ReferenceDataMode { erefdataCompare, erefdataCreateMissing, erefdataUpdateChanged, erefdataUpdateAll }
	Mode of operation for reference data handling. More...

Functions
static AwhTestParameters	getAwhTestParameters (int eawhgrowth, int eawhpotential)
	Helper function to set up the C-style AWH parameters for the test.

static AwhTestParameters	getAwhTestParameters ()
	Helper function to set up the C-style AWH parameters for the test.

bool	pmeSupportsInputForMode (const gmx_hw_info_t &hwinfo, const t_inputrec *inputRec, CodePath mode)
	Tells if this generally valid PME input is supported for this mode.

uint64_t	getSplineModuliDoublePrecisionUlps (int splineOrder)
	For double precision checks, the recursive interpolation and use of trig functions in make_dft_mod require a lot more flops, and thus opportunity for deviation between implementations.

static PmeSafePointer	pmeInitInternal (const t_inputrec inputRec, CodePath mode, const gmx_device_info_t gpuInfo, PmeGpuProgramHandle pmeGpuProgram, size_t atomCount, const Matrix3x3 &box, real ewaldCoeff_q=1.0f, real ewaldCoeff_lj=1.0f)
	PME initialization - internal.

PmeSafePointer	pmeInitEmpty (const t_inputrec inputRec, CodePath mode, const gmx_device_info_t gpuInfo, PmeGpuProgramHandle pmeGpuProgram, const Matrix3x3 &box, real ewaldCoeff_q, real ewaldCoeff_lj)
	Simple PME initialization based on input, no atom data. More...

PmeSafePointer	pmeInitAtoms (const t_inputrec inputRec, CodePath mode, const gmx_device_info_t gpuInfo, PmeGpuProgramHandle pmeGpuProgram, const CoordinatesVector &coordinates, const ChargesVector &charges, const Matrix3x3 &box)
	PME initialization with atom data. More...

static real *	pmeGetRealGridInternal (const gmx_pme_t *pme)
	Getting local PME real grid pointer for test I/O.

static void	pmeGetRealGridSizesInternal (const gmx_pme_t *pme, CodePath mode, IVec &gridSize, IVec &paddedGridSize)
	Getting local PME real grid dimensions.

static t_complex *	pmeGetComplexGridInternal (const gmx_pme_t *pme)
	Getting local PME complex grid pointer for test I/O.

static void	pmeGetComplexGridSizesInternal (const gmx_pme_t *pme, IVec &gridSize, IVec &paddedGridSize)
	Getting local PME complex grid dimensions.

template<typename ValueType >
static void	pmeGetGridAndSizesInternal (const gmx_pme_t , CodePath, ValueType &, IVec &, IVec &)
	Getting the PME grid memory buffer and its sizes - template definition.

template<>
void	pmeGetGridAndSizesInternal< real > (const gmx_pme_t pme, CodePath mode, real &grid, IVec &gridSize, IVec &paddedGridSize)
	Getting the PME real grid memory buffer and its sizes.

template<>
void	pmeGetGridAndSizesInternal< t_complex > (const gmx_pme_t pme, CodePath, t_complex &grid, IVec &gridSize, IVec &paddedGridSize)
	Getting the PME complex grid memory buffer and its sizes.

void	pmePerformSplineAndSpread (gmx_pme_t *pme, CodePath mode, bool computeSplines, bool spreadCharges)
	PME spline calculation and charge spreading. More...

static real *	pmeGetSplineDataInternal (const gmx_pme_t *pme, PmeSplineDataType type, int dimIndex)
	Getting the internal spline data buffer pointer.

void	pmePerformSolve (const gmx_pme_t *pme, CodePath mode, PmeSolveAlgorithm method, real cellVolume, GridOrdering gridOrdering, bool computeEnergyAndVirial)
	PME solving.

void	pmePerformGather (gmx_pme_t *pme, CodePath mode, PmeForceOutputHandling inputTreatment, ForcesVector &forces)
	PME force gathering.

void	pmeFinalizeTest (const gmx_pme_t *pme, CodePath mode)
	PME test finalization before fetching the outputs.

void	pmeSetSplineData (const gmx_pme_t *pme, CodePath mode, const SplineParamsDimVector &splineValues, PmeSplineDataType type, int dimIndex)
	Setting atom spline values/derivatives to be used in spread/gather. More...

void	pmeSetGridLineIndices (const gmx_pme_t *pme, CodePath mode, const GridLineIndicesVector &gridLineIndices)
	Setting gridline indices to be used in spread/gather. More...

size_t	pmeGetGridPlainIndexInternal (const IVec &index, const IVec &paddedGridSize, GridOrdering gridOrdering)
	Getting plain index into the complex 3d grid.

template<typename ValueType >
static void	pmeSetGridInternal (const gmx_pme_t *pme, CodePath mode, GridOrdering gridOrdering, const SparseGridValuesInput< ValueType > &gridValues)
	Setting real or complex grid.

void	pmeSetRealGrid (const gmx_pme_t *pme, CodePath mode, const SparseRealGridValuesInput &gridValues)
	Setting real grid to be used in gather.

void	pmeSetComplexGrid (const gmx_pme_t *pme, CodePath mode, GridOrdering gridOrdering, const SparseComplexGridValuesInput &gridValues)
	Setting complex grid to be used in solve.

SplineParamsDimVector	pmeGetSplineData (const gmx_pme_t *pme, CodePath mode, PmeSplineDataType type, int dimIndex)
	Getting the single dimension's spline values or derivatives.

GridLineIndicesVector	pmeGetGridlineIndices (const gmx_pme_t *pme, CodePath mode)
	Getting the gridline indices.

template<typename ValueType >
static SparseGridValuesOutput < ValueType >	pmeGetGridInternal (const gmx_pme_t *pme, CodePath mode, GridOrdering gridOrdering)
	Getting real or complex grid - only non zero values.

SparseRealGridValuesOutput	pmeGetRealGrid (const gmx_pme_t *pme, CodePath mode)
	Getting the real grid (spreading output of pmePerformSplineAndSpread())

SparseComplexGridValuesOutput	pmeGetComplexGrid (const gmx_pme_t *pme, CodePath mode, GridOrdering gridOrdering)
	Getting the complex grid output of pmePerformSolve()

PmeOutput	pmeGetReciprocalEnergyAndVirial (const gmx_pme_t *pme, CodePath mode, PmeSolveAlgorithm method)
	Getting the reciprocal energy and virial.

const char *	codePathToString (CodePath codePath)
	Return a string useful for human-readable messages describing a `codePath`.

const PmeTestEnvironment *	getPmeTestEnv ()
	Get the test environment.

void	callAddGlobalTestEnvironment ()
	This constructs the test environment during setup of the unit test so that they can use the hardware context. More...

static gmx_hw_info_t *	hardwareInit ()
	Simple hardware initialization.

template<typename T >
ArrayRef< char >	charArrayRefFromArray (T *data, size_t size)
	Convenience function to transform a view into one with base type of (non-const) char. More...

template<typename T >
void	runTest (const gmx_gpu_info_t &gpuInfo, ArrayRef< T > input, ArrayRef< T > output)
	Does a device transfer of `input` to the device in `gpuInfo`, and back to `output`.

template<typename VectorType >
bool	isPinned (const VectorType &v)
	Helper function for wrapping a call to isHostMemoryPinned.

template<typename T >
void	fillInputContents (ArrayRef< T > inputRef, int scaleFactor)
	Initialization overload for non-BasicVector.

template<typename T >
void	fillInputContents (ArrayRef< BasicVector< T >> inputRef, int scaleFactor)
	Initialization overload for BasicVector.

template<typename PaddedVectorOfT >
void	fillInput (PaddedVectorOfT *input, int scaleFactor)
	Dispatcher function for filling.

template<typename T >
void	compareViews (ArrayRef< T > input, ArrayRef< T > output)
	Comparison overload for non-BasicVector.

template<typename T >
void	compareViews (ArrayRef< BasicVector< T >> input, ArrayRef< BasicVector< T >> output)
	Comparison overload for BasicVector<T>

static const std::array < gmx::RVec, 51 >	c_waterPositions ({{{.130,-.041,-.291},{.120,-.056,-.192},{.044,-.005,-.327},{-.854,-.406,.477},{-.900,-.334,.425},{-.858,-.386,.575},{.351,-.061,.853},{.401,-.147,.859},{.416,.016,.850},{-.067,-.796,.873},{-.129,-.811,.797},{-.119,-.785,.958},{-.635,-.312,-.356},{-.629,-.389,-.292},{-.687,-.338,-.436},{.321,-.919,.242},{.403,-.880,.200},{.294,-1.001,.193},{-.404,.735,.728},{-.409,.670,.803},{-.324,.794,.741},{.461,-.596,-.135},{.411,-.595,-.221},{.398,-.614,-.059},{-.751,-.086,.237},{-.811,-.148,.287},{-.720,-.130,.152},{.202,.285,-.364},{.122,.345,-.377},{.192,.236,-.278},{-.230,-.485,.081},{-.262,-.391,.071},{-.306,-.548,.069},{.464,-.119,.323},{.497,-.080,.409},{.540,-.126,.258},{-.462,.107,.426},{-.486,.070,.336},{-.363,.123,.430},{.249,-.077,-.621},{.306,-.142,-.571},{.233,-.110,-.714},{-.922,-.164,.904},{-.842,-.221,.925},{-.971,-.204,.827},{.382,.700,.480},{.427,.610,.477},{.288,.689,.513},{.781,.264,-.113},{.848,.203,-.070},{.708,.283,-.048}}})
	Database of 51 water atom input positions (taken from spc216.gro) for use as test inputs.

void	compareEnergyFrames (const EnergyFrame &reference, const EnergyFrame &test, const EnergyTolerances &tolerances)
	Compare all fields of reference with all matching fields from test. More...

void	checkEnergiesAgainstReferenceData (const std::string &energyFilename, const EnergyTolerances &energiesToMatch, TestReferenceChecker *checker)
	Check a subset of the energies found in an energy file against reference data. More...

EnergyFrameReaderPtr	openEnergyFileToReadFields (const std::string &filename, const std::vector< std::string > &requiredEnergyFieldNames)
	Open the file and return an object that can read the required fields from frames of an .edr file. More...

static t_enxframe *	make_enxframe ()
	Helper function to obtain resources.

void	done_enxframe (t_enxframe *fr)
	Helper function to clean up resources. More...

template<typename Map >
std::vector< std::string >	getKeys (const Map &m)
	Convenience function to get std::string keys from a map. More...

bool	isNumberOfPpRanksSupported (const std::string &simulationName, int possibleNumberOfPpRanks)
	Return whether the number of ranks is supported by the simulation `simulationName` in the database. More...

std::string	reportNumbersOfPpRanksSupported (const std::string &simulationName)
	Return a string describing the numbers of ranks supported for the simulation `simulationName` in the database.

MdpFieldValues	prepareMdpFieldValues (const char simulationName, const char integrator, const char tcoupl, const char pcoupl)
	Set up values for an .mdp file that permits a highly reproducible simulation. More...

std::string	prepareMdpFileContents (const MdpFieldValues &mdpFieldValues)
	Make a string containing an .mdp file from the `mdpFieldValues`. More...

static void	organizeMdpFile (SimulationRunner *runner)
	Build a simple .mdp file.

static void	compareBox (const TrajectoryFrame &reference, const TrajectoryFrame &test, const TrajectoryFrameMatchSettings &matchSettings, const FloatingPointTolerance tolerance)
	Compares the box from `reference` and `test` according to the `matchSettings` and `tolerance`. More...

static std::vector< RVec >	putAtomsInBox (const TrajectoryFrame &frame)
	Help put all atom positions in `frame` into its box. More...

static void	comparePositions (const TrajectoryFrame &reference, const TrajectoryFrame &test, const TrajectoryFrameMatchSettings &matchSettings, const FloatingPointTolerance tolerance)
	Compares the positions from `reference` and `test` according to the `matchSettings` and `tolerance`.

static void	compareVelocities (const TrajectoryFrame &reference, const TrajectoryFrame &test, const TrajectoryFrameMatchSettings &matchSettings, const FloatingPointTolerance tolerance)
	Compares the velocities from `reference` and `test` according to the `matchSettings` and `tolerance`.

static void	compareForces (const TrajectoryFrame &reference, const TrajectoryFrame &test, const TrajectoryFrameMatchSettings &matchSettings, const FloatingPointTolerance tolerance)
	Compares the forces from `reference` and `test` according to the `matchSettings` and `tolerance`.

void	compareTrajectoryFrames (const TrajectoryFrame &reference, const TrajectoryFrame &test, const TrajectoryFrameMatchSettings &matchSettings, const TrajectoryTolerances &tolerances)
	Compare the fields of the two frames for equality given the `matchSettings` and `tolerances`. More...

static t_trxframe *	make_trxframe ()
	Helper function to obtain resources.

void	done_trxframe (t_trxframe *fr)
	Helper function to clean up resources. More...

void	checkConfFile (TextInputStream input, TestReferenceChecker checker, const ConfMatchSettings &settings)
	Adds content of a gro file to TestReferenceChecker object. More...

int	getNumberOfTestMpiRanks ()
	Returns the number of MPI ranks to use for an MPI test. More...

static double	convertDoubleReferenceValue (const std::string &value)
	Helper function to parse a floating-point reference data value.

void	initReferenceData (IOptionsContainer *options)
	Initializes reference data handling. More...

static void	throwIfNonEmptyAndOnlyWhitespace (const std::string &s, const char *id)
	Throw a TestException if the caller tries to write particular refdata that can't work. More...

testing::Matcher< std::tuple < float, float > >	FloatEq (const FloatingPointTolerance &tolerance)
	Make matcher for floats for use with GoogleMock that compare equal when `tolerance` is satisifed. More...

testing::Matcher< std::tuple < double, double > >	DoubleEq (const FloatingPointTolerance &tolerance)
	Make matcher for doubles for use with GoogleMock that compare equal when `tolerance` is satisifed. More...

testing::Matcher< std::tuple < real, real > >	RealEq (const FloatingPointTolerance &tolerance)
	Make matcher for reals for use with GoogleMock that compare equal when `tolerance` is satisifed. More...

testing::Matcher< std::tuple < RVec, RVec > >	RVecEq (const FloatingPointTolerance &tolerance)
	Make matcher for RVecs for use with GoogleMock that compare equal when `tolerance` is satisifed. More...

void	registerTestOptions (const char name, TestOptionsProvider provider)
	Registers a test option provider with the test framework. More...

void	initTestOptions (IOptionsContainer *options)
	Initializes the options from all registered test providers. More...

void	checkXvgFile (TextInputStream input, TestReferenceChecker checker, const XvgMatchSettings &settings)
	Adds content of xvg file to TestReferenceChecker object. More...

Variables
const double	g_coords []
	Database of 21 test coordinates that represent a trajectory */. More...

constexpr int64_t	c_splineModuliSinglePrecisionUlps = 1
	Spline moduli are computed in double precision, so they're very good in single precision.

matrix	g_box = {{real(1.86206), 0, 0}, {0, real(1.86206), 0}, {0, 0, real(1.86206)}}
	Simple cubic simulation box to use in tests.

static const char *	g_butaneTopFileFormatString
	Format string for building a configurable .top file.

static bool	g_bDeleteFilesAfterTest = true
	Controls whether TestFileManager should delete temporary files after the test finishes. More...

Function Documentation

void gmx::test::callAddGlobalTestEnvironment ( )

This constructs the test environment during setup of the unit test so that they can use the hardware context.

Implement a stub definition for tests that don't ask for a real one.

Declare a function that all unit test implementations can use to set up any environment that they need.

When registering the unit test in CMake, the HARDWARE_DETECTION flag requires that the code for that unit test implements this function. Otherwise, a default stub implementation is provided.

This approach conforms to the recommendation by GoogleTest to arrange for the code that sets up the global test environment to be called from main, rather than potentially rely on brittle static initialization order.

template<typename T >

ArrayRef<char> gmx::test::charArrayRefFromArray	(	T *	data,
		size_t	size
	)

Convenience function to transform a view into one with base type of (non-const) char.

This transformation is useful for using containers with C APIs where the function signature is not declared const even where the semantics of the usage actually are const.

Parameters

[in]	data	The data pointer.
[in]	size	The size of the data pointer (in T).

Template Parameters

T	The base type of the container

void gmx::test::checkConfFile	(	TextInputStream *	input,
		TestReferenceChecker *	checker,
		const ConfMatchSettings &	settings
	)

Adds content of a gro file to TestReferenceChecker object.

Parameters

[in]	input	Stream that provides the gro content.
[in,out]	checker	Checker to use.
[in]	settings	Settings to use for matching.

Parses a gro file from the input stream, and checks the contents against reference data (only first two lines for now).

See Also: ConfMatch

void gmx::test::checkEnergiesAgainstReferenceData	(	const std::string &	energyFilename,
		const EnergyTolerances &	energiesToMatch,
		TestReferenceChecker *	checker
	)

Check a subset of the energies found in an energy file against reference data.

Opens the energy file, loops over all frames, matching the indicated energies against refdata at the given tolerance.

Parameters

[in]	energyFilename	The name of an energy file.
[in]	energiesToMatch	Set of energies to match at given tolerances.
[in]	checker	Root checker for reference data.

Todo:: This is quite similar to the functionality used in PmeTest, and we should consider reducing the duplication.

void gmx::test::checkXvgFile	(	TextInputStream *	input,
		TestReferenceChecker *	checker,
		const XvgMatchSettings &	settings
	)

Adds content of xvg file to TestReferenceChecker object.

Parameters

[in]	input	Stream that provides the xvg content.
[in,out]	checker	Checker to use.
[in]	settings	Settings to use for matching.

Parses an xvg file from the input stream, and checks the contents against reference data. settings can be used to customize the matching. Only a single data set is supported (but multiple columns work). A subset of xmgrace formatting is also checked; static content that is nearly always the same is skipped.

See Also: XvgMatch

static void gmx::test::compareBox	(	const TrajectoryFrame &	reference,
		const TrajectoryFrame &	test,
		const TrajectoryFrameMatchSettings &	matchSettings,
		const FloatingPointTolerance	tolerance
	)

static

Compares the box from reference and test according to the matchSettings and tolerance.

Todo:: This could be streamlined when we have a proper 3D matrix class and view.

void gmx::test::compareEnergyFrames	(	const EnergyFrame &	reference,
		const EnergyFrame &	test,
		const EnergyTolerances &	tolerances
	)

Compare all fields of reference with all matching fields from test.

Ignore any key found in either reference or test that is not found in the other. For all keys found in both frames, compare the values with EXPECT_REAL_EQ_TOL and the given tolerance for that key.

void gmx::test::compareTrajectoryFrames	(	const TrajectoryFrame &	reference,
		const TrajectoryFrame &	test,
		const TrajectoryFrameMatchSettings &	matchSettings,
		const TrajectoryTolerances &	tolerances
	)

Compare the fields of the two frames for equality given the matchSettings and tolerances.

The two frames are required to have valid and matching values for time and step. According to matchSettings, box, positions, velocities and/or forces will be compared between frames, using the tolerances. Comparisons will only occur when both frames have the requisite data, and will be expected to be equal within the matching component of tolerances. If a comparison fails, a GoogleTest expectation failure will be given. If a comparison is required by matchSettings but cannot be done because either (or both) frames lack the requisite data, descriptive expectation failures will be given.

void gmx::test::done_enxframe ( t_enxframe * fr )

Helper function to clean up resources.

Helper function to free resources (NB free_enxframe only frees the contents, not the pointer itself)

void gmx::test::done_trxframe ( t_trxframe * fr )

Helper function to clean up resources.

Helper function to free all resources.

testing::Matcher< std::tuple< double, double > > gmx::test::DoubleEq ( const FloatingPointTolerance & tolerance )

Make matcher for doubles for use with GoogleMock that compare equal when tolerance is satisifed.

Used like

EXPECT_THAT(testDoubles, Pointwise(DoubleEq(tolerance), referenceDoubles));

testing::Matcher< std::tuple< float, float > > gmx::test::FloatEq ( const FloatingPointTolerance & tolerance )

Make matcher for floats for use with GoogleMock that compare equal when tolerance is satisifed.

Used like

EXPECT_THAT(testFloats, Pointwise(FloatEq(tolerance), referenceFloats));

template<typename Map >

std::vector<std::string> gmx::test::getKeys ( const Map & m )

Convenience function to get std::string keys from a map.

This function can be used to provide an input for openEnergyFileToReadFields().

Todo:: This returns a copy of the keys, which is convenient, but inefficient. Alternatively, this could return a view of the keys from a range rather than a container, but there's no implementation of that in C++11 at the moment.

bool gmx::test::isNumberOfPpRanksSupported	(	const std::string &	simulationName,
		int	possibleNumberOfPpRanks
	)

Return whether the number of ranks is supported by the simulation simulationName in the database.

This method lets test runners understand when end-to-end tests should be expected to work.

EnergyFrameReaderPtr gmx::test::openEnergyFileToReadFields	(	const std::string &	filename,
		const std::vector< std::string > &	requiredEnergyFieldNames
	)

Open the file and return an object that can read the required fields from frames of an .edr file.

Parameters

[in]	filename	Name of the energy file to use
[in]	requiredEnergyFieldNames	Names of the energy fields that the caller requires to be present for an .edr file frame to be considered valid

Exceptions

FileIOError	If the .edr file cannot be opened
APIError	If any required energy field is not present in the file
std::bad_alloc	When out of memory

This function is intended to have the main responsibility for making EnergyFrameReader objects.

PmeSafePointer gmx::test::pmeInitAtoms	(	const t_inputrec *	inputRec,
		CodePath	mode,
		const gmx_device_info_t *	gpuInfo,
		PmeGpuProgramHandle	pmeGpuProgram,
		const CoordinatesVector &	coordinates,
		const ChargesVector &	charges,
		const Matrix3x3 &	box
	)

PME initialization with atom data.

PME initialization with atom data and system box.

PmeSafePointer gmx::test::pmeInitEmpty	(	const t_inputrec *	inputRec,
		CodePath	mode,
		const gmx_device_info_t *	gpuInfo,
		PmeGpuProgramHandle	pmeGpuProgram,
		const Matrix3x3 &	box,
		real	ewaldCoeff_q,
		real	ewaldCoeff_lj
	)

Simple PME initialization based on input, no atom data.

Simple PME initialization (no atom data)

void gmx::test::pmePerformSplineAndSpread	(	gmx_pme_t *	pme,
		CodePath	mode,
		bool	computeSplines,
		bool	spreadCharges
	)

PME spline calculation and charge spreading.

PME spline computation and charge spreading.

void gmx::test::pmeSetGridLineIndices	(	const gmx_pme_t *	pme,
		CodePath	mode,
		const GridLineIndicesVector &	gridLineIndices
	)

Setting gridline indices to be used in spread/gather.

Setting gridline indices be used in spread/gather.

void gmx::test::pmeSetSplineData	(	const gmx_pme_t *	pme,
		CodePath	mode,
		const SplineParamsDimVector &	splineValues,
		PmeSplineDataType	type,
		int	dimIndex
	)

Setting atom spline values/derivatives to be used in spread/gather.

Setting atom spline values or derivatives to be used in spread/gather.

MdpFieldValues gmx::test::prepareMdpFieldValues	(	const char *	simulationName,
		const char *	integrator,
		const char *	tcoupl,
		const char *	pcoupl
	)

Set up values for an .mdp file that permits a highly reproducible simulation.

An internal database of several kinds of simulation useful for such comparisons is available, whose simulationName keys are

argon12
argon5832
spc5
spc216
alanine_vsite_vacuo
alanine_vsite_solvated
glycine_vacuo
glycine_no_constraints_vacuo
nonanol_vacuo

Some of these systems are pretty minimal, because having few atoms means few interactions, highly reproducible forces, and allows tests to focus on the correctness of the implementation of high-level mdrun features. The boxes are of a reasonable size so that domain decomposition is possible. The pressure-coupling parameters are isotropic, and set up so that there will not be dramatic collapse of volume over the handful of MD steps that will be run. A single temperature-coupling group is used.

Parameters

[in]	simulationName	The name of the simulation, which indexes the database
[in]	integrator	The integrator to use
[in]	tcoupl	The temperature-coupling algorithm to use
[in]	pcoupl	The pressure-coupling algorithm to use

Returns: Mdp file values

Exceptions

std::bad_alloc if out of memory std::out_of_range if simulationName is not in the database

std::string gmx::test::prepareMdpFileContents ( const MdpFieldValues & mdpFieldValues )

Make a string containing an .mdp file from the mdpFieldValues.

Exceptions

std::bad_alloc if out of memory

static std::vector<RVec> gmx::test::putAtomsInBox ( const TrajectoryFrame & frame )

static

Help put all atom positions in frame into its box.

This can perhaps go away when frame->x is a container.

testing::Matcher< std::tuple< real, real > > gmx::test::RealEq ( const FloatingPointTolerance & tolerance )

Make matcher for reals for use with GoogleMock that compare equal when tolerance is satisifed.

Used like

EXPECT_THAT(testReals, Pointwise(RealEq(tolerance), referenceReals));

testing::Matcher< std::tuple< RVec, RVec > > gmx::test::RVecEq ( const FloatingPointTolerance & tolerance )

Make matcher for RVecs for use with GoogleMock that compare equal when tolerance is satisifed.

Used like

EXPECT_THAT(testRVecs, Pointwise(RVecEq(tolerance), referenceRVecs));

static void gmx::test::throwIfNonEmptyAndOnlyWhitespace	(	const std::string &	s,
		const char *	id
	)

static

Throw a TestException if the caller tries to write particular refdata that can't work.

If the string to write is non-empty and has only whitespace, TinyXML2 can't read it correctly, so throw an exception for this case, so that we can't accidentally use it and run into mysterious problems.

Todo:: Eliminate this limitation of TinyXML2. See e.g. https://github.com/leethomason/tinyxml2/issues/432

Variable Documentation

bool gmx::test::g_bDeleteFilesAfterTest = true

static

Controls whether TestFileManager should delete temporary files after the test finishes.

const double gmx::test::g_coords[]

Initial value:

= {
62,
70,
68,
80,
93,
87,
16,
14,
95,
89,
91,
86,
88,
79,
75,
82,
74,
70,
68,
71,
73
}

Database of 21 test coordinates that represent a trajectory */.

Description

Classes

Typedefs

Enumerations

Functions

Variables

Function Documentation

Variable Documentation