functions & macros to test the difference between floats More...

Classes
class	DummyRCUSvc

class	InitGaudi
	Generic test fixture to setup Gaudi. More...

class	InitGaudiGoogleTest

struct	Leakcheck

struct	LeakCheckDisable

class	normal_distribution

struct	RNG
	Generator compatible with the STL RandomNumberGenerator. More...

class	TestAlloc
	To test handling of non-standard memory allocators. More...

class	TestedValue

class	uniform_real_distribution

struct	URNG
	Generator compatible with the C++11 STL UniformRandomNumberGenerator. More...

Functions
bool	initGaudi (ISvcLocator *&pSvcLoc)
	Minimal Gaudi initialization for unit testing without job options. More...

bool	initGaudi (const std::string &jobOptsFile, ISvcLocator *&pSvcLoc)
	Minimal Gaudi initialization for unit testing. More...

void	referenceGaudiSymbols ()

template<typename T >
bool	cmp_eq (T a, T b)

template<>
bool	cmp_eq< float > (float a, float b)

template<>
bool	cmp_eq< double > (double a, double b)

bool	floatEQ (float lhs, float rhs)

bool	floatNEQ (float lhs, float rhs)

bool	isEqual (double x1, double x2, double thresh=1e-6)

uint32_t	rng_seed (uint32_t &seed)
	Generate a random number between 0 and `rngmax`. More...

float	randf_seed (uint32_t &seed, float rmax, float rmin=0)
	Generate a floating-point random number between `rmin` and `rmax`. More...

int	randi_seed (uint32_t &seed, int rmax, int rmin=0)
	Generate an integer random number between `rmin` and `rmax`. More...

uint32_t rng	ATLAS_NOT_REENTRANT ()

int randi	ATLAS_NOT_REENTRANT (int rmax, int rmin=0)

float randf	ATLAS_NOT_REENTRANT (float rmax, float rmin=0)

bool	setupStoreGate (std::string progname, std::string options_file="")
	Helper for setting up StoreGate for regression tests. More...

void	testCreate (StoreGateSvc &rSG)

void	testRecord (StoreGateSvc &rSG)

void	testSymLink (StoreGateSvc &rSG)

void	test_symlink2 (StoreGateSvc &rSG)

void	test_symlink3 (StoreGateSvc &rSG)

void	testContains (StoreGateSvc &rSG)

void	testFolders (StoreGateSvc &rSG)

void	testRetrieve (StoreGateSvc &rSG)

void	testTryRetrieve (StoreGateSvc &rSG)

void	testReadPrivateCopy (StoreGateSvc &rSG)

void	testRetrievePrivateCopy (StoreGateSvc &rSG)

void	testRemove (StoreGateSvc &rSG)

void testBind	ATLAS_NOT_THREAD_SAFE (StoreGateSvc &rSG)

void	testClear (StoreGateSvc &rSG)

void	testTransientSwap (StoreGateSvc &rSG)

void	testVersionedKey (StoreGateSvc &rSG)

void	testKeys (StoreGateSvc &rSG)

void	testRetrieveAux (StoreGateSvc &rSG)

void	testBoundReset (StoreGateSvc &rSG)

void	testRecordObject (StoreGateSvc &rSG)

void	testWriteAux (StoreGateSvc &rSG)

void	varHandleTest (SGTest::TestStore &)

void	resetableTest (void)

void	refCountTest (void)

bool	initMcEventCollection (ISvcLocator *&pSvcLoc, std::vector< HepMC::GenParticlePtr > &genPartVector, const bool initGaudi=true)

void	populateGenEvent (HepMC::GenEvent &ge, int pdgid1, int pdgid2, std::vector< HepMC::GenParticlePtr > &genPartVector)

void	populateFilteredGenEvent (HepMC::GenEvent &ge, std::vector< HepMC::GenParticlePtr > &genPartVector)

int	maximumBarcode (std::vector< HepMC::GenParticlePtr > &genPartList)

Variables
std::unordered_set< void * > *	allocs = nullptr

Detailed Description

functions & macros to test the difference between floats

Function Documentation

◆ ATLAS_NOT_REENTRANT() [1/3]

uint32_t rng Athena_test::ATLAS_NOT_REENTRANT ( )

inline

Definition at line 90 of file random.h.

90 { return rng_seed(seed); }

◆ ATLAS_NOT_REENTRANT() [2/3]

float randf Athena_test::ATLAS_NOT_REENTRANT	(	float	rmax,
		float	rmin = `0`
	)

inline

Definition at line 94 of file random.h.

94 { return randf_seed (seed, rmax, rmin); }

◆ ATLAS_NOT_REENTRANT() [3/3]

int randi Athena_test::ATLAS_NOT_REENTRANT	(	int	rmax,
		int	rmin = `0`
	)

inline

Definition at line 92 of file random.h.

92 { return randi_seed (seed, rmax, rmin); }

◆ ATLAS_NOT_THREAD_SAFE()

void testBind Athena_test::ATLAS_NOT_THREAD_SAFE ( StoreGateSvc & rSG )

◆ cmp_eq()

template<typename T >

bool Athena_test::cmp_eq	(	T	a,
		T	b
	)

Definition at line 18 of file expect.h.

18 { return a == b; }

◆ cmp_eq< double >()

template<>

bool Athena_test::cmp_eq< double >	(	double	a,
		double	b
	)

Definition at line 22 of file expect.h.

22 { return std::abs(a - b) < 1.e-6; }

◆ cmp_eq< float >()

template<>

bool Athena_test::cmp_eq< float >	(	float	a,
		float	b
	)

Definition at line 20 of file expect.h.

20 { return std::abs(a - b) < 1.e-4; }

◆ floatEQ()

bool Athena_test::floatEQ	(	float	lhs,
		float	rhs
	)

inline

Definition at line 17 of file FLOATassert.h.

                                      {
     return fabs(lhs-rhs)<=FLT_EPSILON;
   }

◆ floatNEQ()

bool Athena_test::floatNEQ	(	float	lhs,
		float	rhs
	)

inline

Definition at line 21 of file FLOATassert.h.

                                       {
     return fabs(lhs-rhs)>FLT_EPSILON;
   }

◆ initGaudi() [1/2]

bool Athena_test::initGaudi	(	const std::string &	jobOptsFile,
		ISvcLocator *&	pSvcLoc
	)

Minimal Gaudi initialization for unit testing.

Parameters

jobOptsFile	job options file name
pSvcLoc	returns a pointer to the Gaudi ServiceLocator

Returns: true on success, false on failure

Definition at line 33 of file initGaudi.cxx.

                                {
         std::cout << "\n\nCannot find job opts " << jobOptsFile << std::endl;
       }
       else {
         std::cout << "\n\nInitializing Gaudi ApplicationMgr using job opts " << jobOptsPath << std::endl;
       }
     }
  
     // Create an instance of ApplicationMgr
     SmartIF<IAppMgrUI> appMgr = Gaudi::createApplicationMgr();
     if(!appMgr.isValid()) {
       std::cout << "Fatal error while creating the ApplicationMgr " << std::endl;
       return false;
     }
  
     SmartIF<IProperty> propMgr(appMgr);
     SmartIF<ISvcLocator> svcLoc(appMgr);
     if(!svcLoc.isValid() || !propMgr.isValid()) {
       std::cout << "Fatal error while retrieving AppMgr interfaces " << std::endl;
       return false;
     }
  
     // Return pointer to ISvcLocator
     pSvcLoc = svcLoc.get();
  
     propMgr->setProperty( "EvtSel", "NONE" ).
       orThrow("Cannnot set EvtSel property", "initGaudi");
     if (jobOptsFile.empty()) {
       propMgr->setProperty( "JobOptionsType", "NONE" ).
         orThrow("Cannnot set JobOptionsType property", "initGaudi");
     } else {
       propMgr->setProperty( "JobOptionsType", "FILE" ).
         orThrow("Cannnot set JobOptionsType property", "initGaudi");
       propMgr->setProperty( "JobOptionsPath", jobOptsPath ).
         orThrow("Cannnot set JobOptionsPath property", "initGaudi");
     }
  
     if (appMgr->configure().isSuccess() && appMgr->initialize().isSuccess()) {
       std::cout<<"ApplicationMgr Ready"<<std::endl;
       return true;
     } else {
       std::cout << "Fatal error while initializing the AppMgr" << std::endl;
       return false;
     }
   }
  
  
   // This is for the benefit of the tests in CLIDComps.
   // By default, a dynamic symbol is not exported from a binary unless

◆ initGaudi() [2/2]

bool Athena_test::initGaudi ( ISvcLocator *& pSvcLoc )

Minimal Gaudi initialization for unit testing without job options.

Parameters

pSvcLoc returns a pointer to the Gaudi ServiceLocator

Returns: true on success, false on failure

Definition at line 28 of file initGaudi.cxx.

29 {

30

◆ initMcEventCollection()

bool Athena_test::initMcEventCollection	(	ISvcLocator *&	pSvcLoc,
		std::vector< HepMC::GenParticlePtr > &	genPartVector,
		const bool	initGaudi = `true`
	)

Definition at line 23 of file initMcEventCollection.cxx.

   {
     if (initGaudi && !Athena_test::initGaudi(pSvcLoc)) {
       std::cerr << "This test can not be run" << std::endl;
       return false;
     }
     // create dummy input McEventCollection with a name that
     // HepMcParticleLink knows about
     SG::WriteHandle<McEventCollection> inputTestDataHandle{"TruthEvent"};
     inputTestDataHandle = std::make_unique<McEventCollection>();
  
     // create a dummy EventContext
     EventContext ctx;
     ctx.setExtension( Atlas::ExtendedEventContext( SG::CurrentEventStore::store() ) );
     Gaudi::Hive::setCurrentContext( ctx );
  
     // Add a dummy GenEvent
     const int process_id1(20);
     const int event_number1(17);
     inputTestDataHandle->push_back(HepMC::newGenEvent(process_id1, event_number1));
     HepMC::GenEvent& ge1 = *(inputTestDataHandle->at(0));
     populateGenEvent(ge1,-11,11,genPartList);
     populateGenEvent(ge1,-13,13,genPartList);
     populateGenEvent(ge1,-11,11,genPartList);
     populateGenEvent(ge1,-13,13,genPartList);
     populateGenEvent(ge1,-11,11,genPartList);
     populateGenEvent(ge1,22,22,genPartList);
     inputTestDataHandle->push_back(new HepMC::GenEvent(ge1));
     HepMC::GenEvent& ge2 = *(inputTestDataHandle->at(1));
     const int event_number2(89);
     ge2.set_event_number(event_number2);
     populateFilteredGenEvent(ge2,genPartList);
     return true;
   }

◆ isEqual()

bool Athena_test::isEqual	(	double	x1,
		double	x2,
		double	thresh = `1e-6`
	)

inline

Definition at line 26 of file FLOATassert.h.

   {
     double den = std::abs(x1+x2);
     if (den < thresh) return true;
     double diff = std::abs (x1-x2) / den;
     if (diff < thresh)
       return true;
     std::cout << "Match failure: " << x1 << " " << x2 << " (" << diff << ")\n";
     return false;
   }

◆ maximumBarcode()

int Athena_test::maximumBarcode ( std::vector< HepMC::GenParticlePtr > & genPartList )

Definition at line 58 of file initMcEventCollection.cxx.

   {
     int maxBarcode{0};
     if (genPartList.empty()) { return maxBarcode; }
     for (HepMC::GenParticlePtr genPart : genPartList)
       {
         maxBarcode = std::max(maxBarcode, HepMC::barcode(genPart));
       }
     return maxBarcode;
   }

◆ populateFilteredGenEvent()

void Athena_test::populateFilteredGenEvent	(	HepMC::GenEvent &	ge,
		std::vector< HepMC::GenParticlePtr > &	genPartVector
	)

< set decay status

Definition at line 97 of file initMcEventCollection.cxx.

   {
     //.......Create new particle (geantino) to link  hits from pileup
     HepMC::GenParticlePtr genPart=HepMC::newGenParticlePtr();
     genPart->set_pdg_id(999); //Geantino
     genPart->set_status(1); 
     HepMC::suggest_barcode(genPart, HepMC::SUPPRESSED_PILEUP_BARCODE );
  
     HepMC::GenVertexPtr genVertex=HepMC::newGenVertexPtr();
     genVertex->add_particle_out(genPart);
     genPartVector.push_back(genPart);
  
     //to set geantino vertex as a truth primary vertex
     HepMC::GenVertexPtr  hScatVx = HepMC::barcode_to_vertex(&ge,-3);
     if (hScatVx!=nullptr) {
       HepMC::FourVector pmvxpos=hScatVx->position();
       genVertex->set_position(pmvxpos);
       //to set geantino kinematic phi=eta=0, E=p=E_hard_scat
 #ifdef HEPMC3
       auto itrp =hScatVx->particles_in().cbegin();
       if (hScatVx->particles_in().size()==2) {
         HepMC::FourVector mom1=(*itrp)->momentum();
         HepMC::FourVector mom2=(*(++itrp))->momentum();
         HepMC::FourVector vxmom;
         vxmom.setPx(mom1.e()+mom2.e());
         vxmom.setPy(0.);
         vxmom.setPz(0.);
         vxmom.setE(mom1.e()+mom2.e());
         genPart->set_momentum(vxmom);
       }
 #else
       HepMC::GenVertex::particles_in_const_iterator itrp =hScatVx->particles_in_const_begin();
       if (hScatVx->particles_in_size()==2) {
         HepMC::FourVector mom1=(*itrp)->momentum();
         HepMC::FourVector mom2=(*(++itrp))->momentum();
         HepMC::FourVector vxmom;
         vxmom.setPx(mom1.e()+mom2.e());
         vxmom.setPy(0.);
         vxmom.setPz(0.);
         vxmom.setE(mom1.e()+mom2.e());
         genPart->set_momentum(vxmom);
       }
 #endif
     }
  
 #ifdef HEPMC3
     if (!ge.vertices().empty()) {
       std::vector<HepMC::GenVertexPtr> vtxvec;
       for (const auto& vtx: ge.vertices()) {
         vtxvec.push_back(vtx);
         ge.remove_vertex(vtx);
       }
       vtxvec.clear();
     }
 #else
     if (!ge.vertices_empty()) {
       HepMC::GenEvent::vertex_iterator itvtx = ge.vertices_begin();
       while (itvtx != ge.vertices_end()) {
         HepMC::GenVertexPtr pvtx = *itvtx;
         ++itvtx;
         ge.remove_vertex(pvtx);
         delete pvtx;
       }
     }
 #endif
  
     //.....add new vertex with geantino
     ge.add_vertex(std::move(genVertex));
     HepMC::suggest_barcode(genPart, HepMC::SUPPRESSED_PILEUP_BARCODE );
   }

◆ populateGenEvent()

void Athena_test::populateGenEvent	(	HepMC::GenEvent &	ge,
		int	pdgid1,
		int	pdgid2,
		std::vector< HepMC::GenParticlePtr > &	genPartVector
	)

Definition at line 69 of file initMcEventCollection.cxx.

   {
     int maxBarcode = maximumBarcode(genPartList);
     HepMC::FourVector myPos( 0.0, 0.0, 0.0, 0.0);
     HepMC::GenVertexPtr myVertex = HepMC::newGenVertexPtr( myPos, -1 );
     HepMC::FourVector fourMomentum1( 0.0, 0.0, 1.0, 1.0*CLHEP::TeV);
     HepMC::GenParticlePtr inParticle1 = HepMC::newGenParticlePtr(fourMomentum1, pdgid1, 2);
     myVertex->add_particle_in(inParticle1);
     HepMC::FourVector fourMomentum2( 0.0, 0.0, -1.0, 1.0*CLHEP::TeV);
     HepMC::GenParticlePtr inParticle2 = HepMC::newGenParticlePtr(fourMomentum2, pdgid2, 2);
     myVertex->add_particle_in(inParticle2);
     HepMC::FourVector fourMomentum3( 0.0, 1.0, 0.0, 1.0*CLHEP::TeV);
     HepMC::GenParticlePtr inParticle3 = HepMC::newGenParticlePtr(fourMomentum3, pdgid1, 1);
     myVertex->add_particle_out(inParticle3);
     genPartList.push_back(inParticle3);
     HepMC::FourVector fourMomentum4( 0.0, -1.0, 0.0, 1.0*CLHEP::TeV);
     HepMC::GenParticlePtr inParticle4 = HepMC::newGenParticlePtr(fourMomentum4, pdgid2, 1);
     myVertex->add_particle_out(inParticle4);
     genPartList.push_back(inParticle4);
     ge.add_vertex( myVertex );
     HepMC::suggest_barcode(inParticle1,maxBarcode+1);
     HepMC::suggest_barcode(inParticle2,maxBarcode+2);
     HepMC::suggest_barcode(inParticle3,maxBarcode+3);
     HepMC::suggest_barcode(inParticle4,maxBarcode+4);
     HepMC::set_signal_process_vertex(&ge, myVertex );
     ge.set_beam_particles(std::move(inParticle1),std::move(inParticle2));
   }

◆ randf_seed()

float Athena_test::randf_seed	(	uint32_t &	seed,
		float	rmax,
		float	rmin = `0`
	)

inline

Generate a floating-point random number between rmin and rmax.

Definition at line 53 of file random.h.

 {
   return static_cast<float>(rng_seed(seed)) / static_cast<float>(rngmax) * (rmax-rmin) + rmin;
 }

◆ randi_seed()

int Athena_test::randi_seed	(	uint32_t &	seed,
		int	rmax,
		int	rmin = `0`
	)

inline

Generate an integer random number between rmin and rmax.

Definition at line 61 of file random.h.

 {
   return static_cast<int> (randf_seed (seed, rmax, rmin));
 }

◆ refCountTest()

void Athena_test::refCountTest ( void )

◆ referenceGaudiSymbols()

void Athena_test::referenceGaudiSymbols ( )

Definition at line 98 of file initGaudi.cxx.

100 {

101 ISvcLocator* pSvcLoc{};

◆ resetableTest()

void Athena_test::resetableTest ( void )

◆ rng_seed()

uint32_t Athena_test::rng_seed ( uint32_t & seed )

inline

Generate a random number between 0 and rngmax.

Definition at line 44 of file random.h.

 {
   seed = (1664525*seed + 1013904223);
   return seed;
 }

◆ setupStoreGate()

bool Athena_test::setupStoreGate	(	std::string	progname,
		std::string	options_file = `""`
	)

Helper for setting up StoreGate for regression tests.

Parameters

progname	Program name (argv[0]).
options_file	Name of the JO text file to read. If defaulted, one will be generated.

Get StoreGateSvc

Definition at line 28 of file setupStoreGate.cxx.

 {
   // Build job options file if CppUnit_jobOptions.txt is unavailable
   if (options_file.empty()) {
     std::string::size_type pos = progname.rfind ("/");
     if (pos != std::string::npos)
       progname.erase (0, pos+1);
     pos = progname.rfind (".");
     if (pos != std::string::npos)
       progname.erase (pos, std::string::npos);
     options_file = "./" + progname + "_generated.txt";
     (void)remove (options_file.c_str());
     std::ofstream jobopt(options_file.c_str());
  
     // Build a default list of options.
     {
       std::list<std::string> opts;
       opts.push_back("#pragma print off");
       opts.push_back("ApplicationMgr.Dlls += { \"StoreGate\" };");
       //opts.push_back("ApplicationMgr.Dlls += { \"CLIDSvc\" };");
       opts.push_back("ApplicationMgr.ExtSvc += { \"ClassIDSvc\" };");
       opts.push_back("ApplicationMgr.ExtSvc += { \"StoreGateSvc\", \"StoreGateSvc/DetectorStore\", \"StoreGateSvc/ConditionStore\", \"StoreGateSvc/HistoryStore\" };");
       opts.push_back("ApplicationMgr.ExtSvc += { \"ActiveStoreSvc\" };");
       opts.push_back("AuditorSvc.Auditors  += { \"AlgContextAuditor\"};");
       opts.push_back("StoreGateSvc.OutputLevel = 2;");
       opts.push_back("StoreGateSvc.ActivateHistory = false;");
       //opts.push_back("CLIDSvc.OutputLevel = 2;");
       opts.push_back("MessageSvc.useColors = false;");
       opts.push_back("MessageSvc.OutputLevel = 3;");
       // Build job options file from list.
       for ( std::list<std::string>::const_iterator iopt=opts.begin();
             iopt!=opts.end(); ++iopt ) 
       {
         jobopt << *iopt << std::endl;
       }
     }
     jobopt.close();
   }
  
   try {
     ISvcLocator* svcLoc = 0;
     if (!Athena_test::initGaudi(options_file, svcLoc)) {
       std::cerr << "This test can not be run" << std::endl;
       return false;
     }  
     assert( 0 != svcLoc);
     
     SmartIF<StoreGateSvc> storeGate{svcLoc->service( "StoreGateSvc" )};
     assert( storeGate );
     
     if ( !storeGate ) {
       std::string error = "No valid pointer to StoreGateSvc !!";
       std::cerr << error << std::endl;
       return false;
     } else {
       return true;
     }
   } catch ( std::exception& e ) {
     std::cerr << "Caught : " << e.what() << std::endl;
     return false;
   }
 }

◆ test_symlink2()

void Athena_test::test_symlink2 ( StoreGateSvc & rSG )

◆ test_symlink3()

void Athena_test::test_symlink3 ( StoreGateSvc & rSG )

◆ testBoundReset()

void Athena_test::testBoundReset ( StoreGateSvc & rSG )

◆ testClear()

void Athena_test::testClear ( StoreGateSvc & rSG )

◆ testContains()

void Athena_test::testContains ( StoreGateSvc & rSG )

◆ testCreate()

void Athena_test::testCreate ( StoreGateSvc & rSG )

◆ testFolders()

void Athena_test::testFolders ( StoreGateSvc & rSG )

◆ testKeys()

void Athena_test::testKeys ( StoreGateSvc & rSG )

◆ testReadPrivateCopy()

void Athena_test::testReadPrivateCopy ( StoreGateSvc & rSG )

◆ testRecord()

void Athena_test::testRecord ( StoreGateSvc & rSG )

◆ testRecordObject()

void Athena_test::testRecordObject ( StoreGateSvc & rSG )

◆ testRemove()

void Athena_test::testRemove ( StoreGateSvc & rSG )

◆ testRetrieve()

void Athena_test::testRetrieve ( StoreGateSvc & rSG )

◆ testRetrieveAux()

void Athena_test::testRetrieveAux ( StoreGateSvc & rSG )

◆ testRetrievePrivateCopy()

void Athena_test::testRetrievePrivateCopy ( StoreGateSvc & rSG )

◆ testSymLink()

void Athena_test::testSymLink ( StoreGateSvc & rSG )

◆ testTransientSwap()

void Athena_test::testTransientSwap ( StoreGateSvc & rSG )

◆ testTryRetrieve()

void Athena_test::testTryRetrieve ( StoreGateSvc & rSG )

◆ testVersionedKey()

void Athena_test::testVersionedKey ( StoreGateSvc & rSG )

◆ testWriteAux()

void Athena_test::testWriteAux ( StoreGateSvc & rSG )

◆ varHandleTest()

void Athena_test::varHandleTest ( SGTest::TestStore & )

Variable Documentation

◆ allocs

std::unordered_set<void*>* Athena_test::allocs = nullptr

Definition at line 51 of file leakcheck.h.

Classes

Functions

Variables

Detailed Description

Function Documentation

◆ ATLAS_NOT_REENTRANT() [1/3]

◆ ATLAS_NOT_REENTRANT() [2/3]

◆ ATLAS_NOT_REENTRANT() [3/3]

◆ ATLAS_NOT_THREAD_SAFE()

◆ cmp_eq()

◆ cmp_eq< double >()

◆ cmp_eq< float >()

◆ floatEQ()

◆ floatNEQ()

◆ initGaudi() [1/2]

◆ initGaudi() [2/2]

◆ initMcEventCollection()

◆ isEqual()

◆ maximumBarcode()

◆ populateFilteredGenEvent()

◆ populateGenEvent()

◆ randf_seed()

◆ randi_seed()

◆ refCountTest()

◆ referenceGaudiSymbols()

◆ resetableTest()

◆ rng_seed()

◆ setupStoreGate()

◆ test_symlink2()

◆ test_symlink3()

◆ testBoundReset()

◆ testClear()

◆ testContains()

◆ testCreate()

◆ testFolders()

◆ testKeys()

◆ testReadPrivateCopy()

◆ testRecord()

◆ testRecordObject()

◆ testRemove()

◆ testRetrieve()

◆ testRetrieveAux()

◆ testRetrievePrivateCopy()

◆ testSymLink()

◆ testTransientSwap()

◆ testTryRetrieve()

◆ testVersionedKey()

◆ testWriteAux()

◆ varHandleTest()

Variable Documentation

◆ allocs