Athena_test Namespace Reference

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

Classes
class	InitGaudiGoogleTest
class	TestedValue
class	InitGaudi
	Generic test fixture to setup Gaudi. More...
struct	LeakCheckDisable
struct	Leakcheck
struct	RNG
	Generator compatible with the STL RandomNumberGenerator. More...
struct	URNG
	Generator compatible with the C++11 STL UniformRandomNumberGenerator. More...
class	normal_distribution
class	uniform_real_distribution
class	TestAlloc
	To test handling of non-standard memory allocators. More...
class	DummyRCUSvc

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	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); }

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.