Athena_test Namespace Reference

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.
bool	initGaudi (const std::string &jobOptsFile, ISvcLocator *&pSvcLoc)
	Minimal Gaudi initialization for unit testing.
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.
float	randf_seed (uint32_t &seed, float rmax, float rmin=0)
	Generate a floating-point random number between rmin and rmax.
int	randi_seed (uint32_t &seed, int rmax, int rmin=0)
	Generate an integer random number between rmin and rmax.
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.
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
static const uint32_t	rngmax = static_cast<uint32_t> (-1)
	Maximum number generated.
static uint32_t	seed = 1

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.

{ 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.

{ 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.

{ 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.

{  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.

{ 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.

{ 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 29 of file initGaudi.cxx.

                                                                      {
 
    std::string jobOptsPath;
    if (!jobOptsFile.empty()) {
      jobOptsPath = System::PathResolver::find_file(jobOptsFile, "JOBOPTSEARCHPATH");
      if (jobOptsPath.empty()) {
        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;
    }
  }

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 24 of file initGaudi.cxx.

                                        {
    return initGaudi({}, pSvcLoc);
  }

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 94 of file initGaudi.cxx.

  {
    ModuleLoadedIncident inc2 ("", "");
  }

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.

rngmax

const uint32_t Athena_test::rngmax = static_cast<uint32_t> (-1)

static

Maximum number generated.

Definition at line 39 of file random.h.

seed

uint32_t Athena_test::seed = 1

static

Definition at line 88 of file random.h.