LArSoft  v09_90_00
Liquid Argon Software toolkit - https://larsoft.org/
testing::GeometryTesterEnvironment< ConfigurationClass > Class Template Reference

Environment for a geometry test. More...

#include "geometry_unit_test_base.h"

Inheritance diagram for testing::GeometryTesterEnvironment< ConfigurationClass >:
testing::TesterEnvironment< ConfigurationClass > testing::BasicTesterEnvironment< ConfigurationClass >

Public Types

using SharedGeoPtr_t = GeoResources_t::ResourcePtr_t
 
using Configuration_t = ConfigurationClass
 

Public Member Functions

 GeometryTesterEnvironment (bool bSetup=true)
 Constructor: sets everything up and declares the test started. More...
 
virtual ~GeometryTesterEnvironment ()
 Destructor: closing remarks. More...
 
template<typename Prov , typename... Args>
Prov * SetupProvider (Args &&...args)
 Sets a service provider up by calling its testing::setupProvider() More...
 
template<typename Prov , typename... Args>
Prov * SetupProviderFromService (std::string name, Args &&...args)
 Sets a service provider up by calling its testing::setupProvider() More...
 
template<typename Prov >
Prov * AcquireProvider (std::unique_ptr< Prov > &&prov)
 Acquires a service provider. More...
 
template<typename Interface , typename Prov , typename... Args>
Prov * SetupProviderFor (Args &&...args)
 Sets a provider up, recording it as implementation of Interface. More...
 
template<typename Interface , typename Prov , typename... Args>
Prov * SetupProviderFromServiceFor (std::string name, Args &&...args)
 Sets a provider up, recording it as implementation of Interface. More...
 
template<typename Interface , typename Prov >
Prov * AcquireProviderFor (std::unique_ptr< Prov > &&prov)
 Acquires a service provider implementing an interface. More...
 
template<typename Prov >
Prov * SimpleProviderSetup ()
 Oversimplified provider setup. More...
 
template<typename Prov >
void DropProvider ()
 Removes and destroys the specified provider. More...
 
template<typename Prov >
Prov const * Provider () const
 Return the specified provider (throws if not available) More...
 
template<typename... Provs>
void FillProviderPack (lar::ProviderPack< Provs... > &pack) const
 Fills the specified provider pack with providers. More...
 
template<typename Prov >
Prov::providers_type ProviderPackFor () const
 Returns a provider pack for the specified provider. More...
 
 GeometryTesterEnvironment (ConfigurationClass const &cfg_obj, bool bSetup=true)
 Setup from a configuration. More...
 
 GeometryTesterEnvironment (ConfigurationClass &&cfg_obj, bool bSetup=true)
 Setup from a configuration. More...
 
geo::GeometryCore const * Geometry () const
 Returns a pointer to the geometry. More...
 
SharedGeoPtr_t SharedGeometry () const
 Returns a pointer to the geometry. More...
 
Configuration retrieval
fhicl::ParameterSet const & Parameters () const
 Returns the full configuration. More...
 
fhicl::ParameterSet ServiceParameters (std::string service_name) const
 Returns the configuration of the specified service. More...
 
fhicl::ParameterSet TesterParameters (std::string test_name) const
 Returns the configuration of the specified test. More...
 
fhicl::ParameterSet TesterParameters () const
 Returns the configuration of the main test (undefined if no main test) More...
 

Static Public Member Functions

static geo::GeometryCore const * GlobalGeometry ()
 
static SharedGeoPtr_t SharedGlobalGeometry ()
 Returns the current global geometry instance (may be nullptr if none) More...
 
static fhicl::ParameterSet CompileParameterSet (std::string cfg)
 Compiles a parameter set from a string. More...
 

Protected Types

using ChannelMapClass = typename ConfigurationClass::ChannelMapClass
 

Protected Member Functions

virtual void Setup ()
 The complete initialization, ran at construction by default. More...
 
virtual std::unique_ptr< geo::GeometryCoreCreateNewGeometry () const
 Creates a new geometry. More...
 
virtual void SetupGeometry ()
 Sets up the geometry (creates and registers it) More...
 
Configuration_t const & Config () const
 Returns a read-only version of the configuration. More...
 
virtual void Configure ()
 Reads and translates the configuration. More...
 
virtual fhicl::ParameterSet DefaultParameters () const
 Creates a full configuration for the test. More...
 
virtual void RegisterGeometry (SharedGeoPtr_t new_geom)
 Get ownership of the specified geometry and registers it as global. More...
 
virtual void RegisterGeometry (geo::GeometryCore const *new_geom)
 Get ownership of the specified geometry and registers it as global. More...
 
virtual void SetupMessageFacility (fhicl::ParameterSet const &pset, std::string appl_name="") const
 Sets up the message facility. More...
 
virtual void SetupMessageFacility () const
 Sets up the message facility. More...
 

Static Protected Member Functions

static fhicl::ParameterSet ParseParameters (std::string config_path)
 Fills the test configuration from file or from default. More...
 

Protected Attributes

ProviderList providers
 list of available providers More...
 

Private Types

using TesterEnvironment_t = TesterEnvironment< ConfigurationClass >
 Base class. More...
 
using GeoResources_t = TestSharedGlobalResource< geo::GeometryCore const >
 this implements the singleton interface More...
 

Private Attributes

ConfigurationClass config
 instance of the configurer More...
 
SharedGeoPtr_t geom
 pointer to the geometry More...
 

Detailed Description

template<typename ConfigurationClass>
class testing::GeometryTesterEnvironment< ConfigurationClass >

Environment for a geometry test.


Template Parameters
ConfigurationClassa class providing compile-time configuration

The test environment is set up on construction.

The environment provides:

This class or a derived one can be used as global fixture for unit tests that require the presence of geometry (in the form of geo::GeometryCore instance).

Unfortunately Boost does not give any control on the initialization of the object, so everything must be ready to go as hard coded. The ConfigurationClass class tries to alleviate that. That is another, small static class that GeometryTesterEnvironment uses to get its parameters.

The requirements for the ConfigurationClass are:

  • ChannelMapClass: concrete type of channel mapping algorithm class
  • std::string ApplicationName(): the application name
  • std::string ConfigurationPath(): path to the configuration file
  • std::string GeometryParameterSetPath(): FHiCL path to the configuration of the geometry; in art is "services.Geometry"
  • std::string TesterParameterSetPath(): FHiCL path to the configuration of the geometry
  • std::string DefaultGeometryConfiguration() returning a FHiCL string to be parsed to extract the default geometry configuration
  • std::string DefaultTesterConfiguration() returning a FHiCL string to be parsed to extract the default test configuration

Whether the configuration comes from a file or from the two provided defaults, it is always expected within the parameter set paths: the default configuration must also contain that path.

Note that there is no room for polymorphism here since the setup happens on construction. Some methods are declared virtual in order to allow to tweak some steps of the set up, but it's not trivial to create a derived class that works correctly: the derived class must declare a new default constructor, and that default constructor must call the protected constructor (GeometryTesterEnvironment<ConfigurationClass>(no_setup))

Definition at line 190 of file geometry_unit_test_base.h.

Member Typedef Documentation

template<typename ConfigurationClass >
using testing::GeometryTesterEnvironment< ConfigurationClass >::ChannelMapClass = typename ConfigurationClass::ChannelMapClass
protected

Definition at line 254 of file geometry_unit_test_base.h.

template<typename ConfigurationClass >
using testing::BasicTesterEnvironment< ConfigurationClass >::Configuration_t = ConfigurationClass
inherited

Definition at line 563 of file unit_test_base.h.

template<typename ConfigurationClass >
using testing::GeometryTesterEnvironment< ConfigurationClass >::GeoResources_t = TestSharedGlobalResource<geo::GeometryCore const>
private

this implements the singleton interface

Definition at line 196 of file geometry_unit_test_base.h.

template<typename ConfigurationClass >
using testing::GeometryTesterEnvironment< ConfigurationClass >::SharedGeoPtr_t = GeoResources_t::ResourcePtr_t

Definition at line 199 of file geometry_unit_test_base.h.

template<typename ConfigurationClass >
using testing::GeometryTesterEnvironment< ConfigurationClass >::TesterEnvironment_t = TesterEnvironment<ConfigurationClass>
private

Base class.

Definition at line 193 of file geometry_unit_test_base.h.

Constructor & Destructor Documentation

template<typename ConfigurationClass >
testing::GeometryTesterEnvironment< ConfigurationClass >::GeometryTesterEnvironment ( bool  bSetup = true)
inline

Constructor: sets everything up and declares the test started.

The configuration is from a default-constructed ConfigurationClass. This is suitable for use as Boost unit test fixture.

Definition at line 207 of file geometry_unit_test_base.h.

207  : TesterEnvironment_t(false)
208  {
209  if (bSetup) Setup();
210  }
virtual void Setup()
The complete initialization, ran at construction by default.
TesterEnvironment< ConfigurationClass > TesterEnvironment_t
Base class.
template<typename ConfigurationClass >
testing::GeometryTesterEnvironment< ConfigurationClass >::GeometryTesterEnvironment ( ConfigurationClass const &  cfg_obj,
bool  bSetup = true 
)
inline

Setup from a configuration.

Parameters
configureran instance of ConfigurationClass

The configuration is from the specified configurer class.

This constructor allows to use a non-default-constructed configuration. This can't be used (at best of my knowledge) when using this class as Boost unit test fixture.

In the r-value-reference constructor, the configurer is moved.

Definition at line 225 of file geometry_unit_test_base.h.

226  : TesterEnvironment_t(cfg_obj, false)
227  {
228  if (bSetup) Setup();
229  }
virtual void Setup()
The complete initialization, ran at construction by default.
TesterEnvironment< ConfigurationClass > TesterEnvironment_t
Base class.
template<typename ConfigurationClass >
testing::GeometryTesterEnvironment< ConfigurationClass >::GeometryTesterEnvironment ( ConfigurationClass &&  cfg_obj,
bool  bSetup = true 
)
inline

Setup from a configuration.

Parameters
configureran instance of ConfigurationClass

The configuration is from the specified configurer class.

This constructor allows to use a non-default-constructed configuration. This can't be used (at best of my knowledge) when using this class as Boost unit test fixture.

In the r-value-reference constructor, the configurer is moved.

Definition at line 230 of file geometry_unit_test_base.h.

231  : TesterEnvironment_t(std::move(cfg_obj), false)
232  {
233  if (bSetup) Setup();
234  }
virtual void Setup()
The complete initialization, ran at construction by default.
TesterEnvironment< ConfigurationClass > TesterEnvironment_t
Base class.
template<typename ConfigurationClass >
testing::GeometryTesterEnvironment< ConfigurationClass >::~GeometryTesterEnvironment ( )
virtual

Destructor: closing remarks.

Definition at line 283 of file geometry_unit_test_base.h.

284  {
285 
286  mf::LogInfo("Test") << config.ApplicationName() << " completed.";
287 
288  } // GeometryTesterEnvironment<>::~GeometryTesterEnvironment()
MaybeLogger_< ELseverityLevel::ELsev_info, false > LogInfo
ConfigurationClass config
instance of the configurer

Member Function Documentation

template<typename ConfigurationClass >
template<typename Prov >
Prov* testing::TesterEnvironment< ConfigurationClass >::AcquireProvider ( std::unique_ptr< Prov > &&  prov)
inlineinherited

Acquires a service provider.

Template Parameters
Provtype of provider
Parameters
provthe provider to be acquired
Returns
a pointer to the provider
See also
SetupProvider()
Exceptions
runtime_errorif the provider already exists

This method registers and takes ownership of the specified provider. It is similar to SetupProvider() except that user is in charge of the preliminary creation and setup of the provider.

Definition at line 815 of file unit_test_base.h.

816  {
817  if (!providers.acquire(std::move(prov))) throw std::runtime_error("Provider already exists!");
818  return providers.getPointer<Prov>();
819  }
T const * getPointer(std::string label="") const
Retrieve the object of type T stored with the specified label.
Definition: ProviderList.h:357
bool acquire(std::unique_ptr< T > &&obj_ptr, std::string label="")
Registers and gets ownership of the specified object.
Definition: ProviderList.h:265
ProviderList providers
list of available providers
template<typename ConfigurationClass >
template<typename Interface , typename Prov >
Prov* testing::TesterEnvironment< ConfigurationClass >::AcquireProviderFor ( std::unique_ptr< Prov > &&  prov)
inlineinherited

Acquires a service provider implementing an interface.

Template Parameters
Provtype of provider
Interfacetype provider alias
Parameters
provthe provider to be acquired
Returns
a pointer to the provider
See also
SetupProviderFor(), AcquireProvider()

This method registers and takes ownership of the specified provider, like AcquireProvider() does. It also registers the provider as an implementation of Interface class, as SetupProviderFor does. It is similar to SetupProvider() except that user is in charge of the preliminar creation and setup of the provider.

Definition at line 887 of file unit_test_base.h.

888  {
889  auto prov_ptr = providers.acquire(prov);
890  providers.set_alias<Prov, Interface>();
891  return prov_ptr;
892  }
bool acquire(std::unique_ptr< T > &&obj_ptr, std::string label="")
Registers and gets ownership of the specified object.
Definition: ProviderList.h:265
ProviderList providers
list of available providers
bool set_alias(std::string alias_label="", std::string prov_label="")
Sets the Alias type as an alias of the Prov provider (with labels)
Definition: ProviderList.h:305
template<typename ConfigurationClass >
fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::CompileParameterSet ( std::string  cfg)
staticinherited

Compiles a parameter set from a string.


Returns
a parameters set with the complete configuration

Definition at line 1069 of file unit_test_base.h.

References fhicl::ParameterSet::make().

1071  {
1072  fhicl::ParameterSet global_pset;
1073  global_pset = fhicl::ParameterSet::make(cfg);
1074  return global_pset;
1075  } // BasicTesterEnvironment<>::CompileParameterSet()
static ParameterSet make(intermediate_table const &tbl)
Definition: ParameterSet.cc:68
template<typename ConfigurationClass >
Configuration_t const& testing::BasicTesterEnvironment< ConfigurationClass >::Config ( ) const
inlineprotectedinherited

Returns a read-only version of the configuration.

Definition at line 638 of file unit_test_base.h.

638 { return config; }
Configuration_t config
instance of the configurer
template<typename ConfigurationClass >
void testing::BasicTesterEnvironment< ConfigurationClass >::Configure ( )
protectedvirtualinherited

Reads and translates the configuration.

Fills the configuration.


The complete configuration (message facility and services) is read and saved, hence accessible by Parameters() method.

The configuration file path is taken by default from the first argument of the test. If that first argument is not present or empty, the default configuration path is received from the configurer. If the configuration path is still empty, a hard-coded configuration is used; otherwise, the FHiCL file specified in that path is parsed and used as full configuration.

Definition at line 1117 of file unit_test_base.h.

1118  {
1119  std::string config_path = config.ConfigurationPath();
1120  params = config_path.empty() ? DefaultParameters() : ParseParameters(config_path);
1121  } // BasicTesterEnvironment::Configure()
fhicl::ParameterSet params
full configuration of the test
static fhicl::ParameterSet ParseParameters(std::string config_path)
Fills the test configuration from file or from default.
virtual fhicl::ParameterSet DefaultParameters() const
Creates a full configuration for the test.
Configuration_t config
instance of the configurer
template<typename ConfigurationClass >
std::unique_ptr< geo::GeometryCore > testing::GeometryTesterEnvironment< ConfigurationClass >::CreateNewGeometry ( ) const
protectedvirtual

Creates a new geometry.

Sets the geometry of the standard detector up.


This function sets up the geometry according to the provided information:

  • the configuration must contain enough information to locate the geometry description file
  • we trust that that geometry works well with the ChannelMapClass specified in ConfigurationClass

Definition at line 302 of file geometry_unit_test_base.h.

References fhicl::ParameterSet::get().

303  {
304 
305  std::string ProviderParameterSetPath = this->Config().GeometryParameterSetPath();
306 
307  //
308  // create the new geometry service provider
309  //
310  fhicl::ParameterSet ProviderConfig =
311  this->Parameters().template get<fhicl::ParameterSet>(ProviderParameterSetPath);
312  auto new_geom = std::make_unique<geo::GeometryCore>(ProviderConfig);
313 
314  std::string RelativePath = ProviderConfig.get<std::string>("RelativePath", "");
315 
316  std::string GDMLFileName = RelativePath + ProviderConfig.get<std::string>("GDML"),
317  ROOTFileName = RelativePath + ProviderConfig.get<std::string>("ROOT");
318 
319  // Search all reasonable locations for the geometry file;
320  // we see if by any chance art's FW_SEARCH_PATH directory is set and try
321  // there;
322  // if not, we do expect the path to be complete enough for ROOT to cope.
323  cet::search_path sp("FW_SEARCH_PATH");
324 
325  std::string ROOTfile;
326  if (!sp.find_file(ROOTFileName, ROOTfile)) ROOTfile = ROOTFileName;
327 
328  // we really don't care of GDML file, since we are not going to run Geant4
329  std::string GDMLfile;
330  if (!sp.find_file(GDMLFileName, GDMLfile)) {
331  mf::LogWarning("CreateNewGeometry") << "GDML file '" << GDMLfile << "' not found.";
332  }
333 
334  // initialize the geometry with the files we have found
335  new_geom->LoadGeometryFile(GDMLfile, ROOTfile);
336 
337  //
338  // create the new channel map
339  //
340  auto const SortingParameters = ProviderConfig.get<fhicl::ParameterSet>("SortingParameters", {});
341 
342  // connect the channel map with the geometry, that shares ownsership
343  // (we give up ours at the end of this method)
344  new_geom->ApplyChannelMap(std::make_unique<ChannelMapClass>(SortingParameters));
345 
346  return new_geom;
347  } // GeometryTesterEnvironment<>::CreateNewGeometry()
fhicl::ParameterSet const & Parameters() const
Returns the full configuration.
Configuration_t const & Config() const
Returns a read-only version of the configuration.
T get(std::string const &key) const
Definition: ParameterSet.h:314
MaybeLogger_< ELseverityLevel::ELsev_warning, false > LogWarning
template<typename ConfigurationClass >
virtual fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::DefaultParameters ( ) const
inlineprotectedvirtualinherited

Creates a full configuration for the test.

Returns
a parameters set with the complete configuration

Definition at line 650 of file unit_test_base.h.

References lar::standalone::SetupMessageFacility().

651  {
652  return CompileParameterSet(config.DefaultConfiguration());
653  }
Configuration_t config
instance of the configurer
static fhicl::ParameterSet CompileParameterSet(std::string cfg)
Compiles a parameter set from a string.
template<typename ConfigurationClass >
template<typename Prov >
void testing::TesterEnvironment< ConfigurationClass >::DropProvider ( )
inlineinherited

Removes and destroys the specified provider.

Template Parameters
Provtype of provider to be destroyed
Exceptions
runtime_errorif the provider was not present

Definition at line 918 of file unit_test_base.h.

919  {
920  if (!providers.erase<Prov>()) throw std::runtime_error("Provider not present!");
921  }
bool erase(std::string label="")
Drops the object with the specified type and label.
Definition: ProviderList.h:285
ProviderList providers
list of available providers
template<typename ConfigurationClass >
template<typename... Provs>
void testing::TesterEnvironment< ConfigurationClass >::FillProviderPack ( lar::ProviderPack< Provs... > &  pack) const
inlineinherited

Fills the specified provider pack with providers.

Exceptions
runtime_errorand everything provider() method can throw
See also
Provider()

Definition at line 936 of file unit_test_base.h.

References trkf::fill().

937  {
938  details::ProviderPackFiller<TesterEnv_t, lar::ProviderPack<Provs...>, Provs...>::fill(*this,
939  pack);
940  } // FillProviderPack()
void fill(const art::PtrVector< recob::Hit > &hits, int only_plane)
Container for a list of pointers to providers.
Definition: ProviderPack.h:111
TesterEnvironment< ConfigurationClass > TesterEnv_t
template<typename ConfigurationClass >
geo::GeometryCore const* testing::GeometryTesterEnvironment< ConfigurationClass >::Geometry ( ) const
inline

Returns a pointer to the geometry.

Definition at line 242 of file geometry_unit_test_base.h.

242 { return geom.get(); }
SharedGeoPtr_t geom
pointer to the geometry
template<typename ConfigurationClass >
static geo::GeometryCore const* testing::GeometryTesterEnvironment< ConfigurationClass >::GlobalGeometry ( )
inlinestatic

Returns the current global geometry instance

Exceptions
std::out_of_rangeif not present

Definition at line 248 of file geometry_unit_test_base.h.

248 { return &GeoResources_t::Resource(); }
static Resource_t & Resource(std::string name="")
Retrieves the specified resource, or throws if not available.
template<typename ConfigurationClass >
fhicl::ParameterSet const& testing::BasicTesterEnvironment< ConfigurationClass >::Parameters ( ) const
inlineinherited

Returns the full configuration.

Definition at line 609 of file unit_test_base.h.

609 { return params; }
fhicl::ParameterSet params
full configuration of the test
template<typename ConfigurationClass >
fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::ParseParameters ( std::string  config_path)
staticprotectedinherited

Fills the test configuration from file or from default.

Returns the configuration from a FHiCL file.

If a FHiCL configuration file is specified, the configuration of the test is read from it according to the parameter set path of the test. Otherwise, it is parsed from the default one provided by the configurer.Parses from file and returns a FHiCL data structure


Parameters
config_pathfull path of the FHiCL configuration file
Returns
a parameters set with the complete configuration from the file

Definition at line 1083 of file unit_test_base.h.

References fhicl::ParameterSet::make(), and fhicl::parse_document().

1085  {
1086  // configuration file lookup policy
1087  char const* fhicl_env = getenv("FHICL_FILE_PATH");
1088  std::string search_path = fhicl_env ? std::string(fhicl_env) + ":" : ".:";
1089  details::FirstAbsoluteOrLookupWithDotPolicy policy(search_path);
1090 
1091  // parse a configuration file; obtain intermediate form
1093  table = fhicl::parse_document(config_path, policy);
1094 
1095  // translate into a parameter set
1096  fhicl::ParameterSet global_pset;
1097  global_pset = fhicl::ParameterSet::make(table);
1098 
1099  return global_pset;
1100  } // BasicTesterEnvironment<>::ParseParameters()
static ParameterSet make(intermediate_table const &tbl)
Definition: ParameterSet.cc:68
intermediate_table parse_document(std::string const &filename, cet::filepath_maker &maker)
Definition: parse.cc:709
template<typename ConfigurationClass >
template<typename Prov >
Prov const* testing::TesterEnvironment< ConfigurationClass >::Provider ( ) const
inlineinherited

Return the specified provider (throws if not available)

Definition at line 925 of file unit_test_base.h.

926  {
927  return providers.getPointer<Prov>();
928  }
T const * getPointer(std::string label="") const
Retrieve the object of type T stored with the specified label.
Definition: ProviderList.h:357
ProviderList providers
list of available providers
template<typename ConfigurationClass >
template<typename Prov >
Prov::providers_type testing::TesterEnvironment< ConfigurationClass >::ProviderPackFor ( ) const
inlineinherited

Returns a provider pack for the specified provider.

Template Parameters
Provtype of the provider
Exceptions
runtime_errorand everything provider() method can throw
See also
FillProviderPack()

The provider is required to have a providers_type type defined as an specialisation of lar::ProviderPack.

Definition at line 952 of file unit_test_base.h.

953  {
954  typename Prov::providers_type pack;
955  FillProviderPack(pack);
956  return pack;
957  } // ProviderPackFor()
void FillProviderPack(lar::ProviderPack< Provs... > &pack) const
Fills the specified provider pack with providers.
template<typename ConfigurationClass >
void testing::GeometryTesterEnvironment< ConfigurationClass >::RegisterGeometry ( SharedGeoPtr_t  new_geom)
protectedvirtual

Get ownership of the specified geometry and registers it as global.

Definition at line 350 of file geometry_unit_test_base.h.

351  {
352  // update the current geometry, that becomes owner;
353  // also update the global one if it happens to be already our previous
354  // (in this case, it becomes co-owner)
355  SharedGeoPtr_t my_old_geom = geom;
356  geom = new_geom;
357  // if the global geometry is already the one we register, don't bother
358  if (SharedGlobalGeometry() != new_geom)
359  GeoResources_t::ReplaceDefaultSharedResource(my_old_geom, new_geom);
360  } // GeometryTesterEnvironment<>::RegisterGeometry()
static bool ReplaceDefaultSharedResource(Resource_t const *old_res_ptr, ResourcePtr_t res_ptr)
Adds a shared resource as default resource only if it is old_res_ptr.
SharedGeoPtr_t geom
pointer to the geometry
static SharedGeoPtr_t SharedGlobalGeometry()
Returns the current global geometry instance (may be nullptr if none)
GeoResources_t::ResourcePtr_t SharedGeoPtr_t
template<typename ConfigurationClass >
virtual void testing::GeometryTesterEnvironment< ConfigurationClass >::RegisterGeometry ( geo::GeometryCore const *  new_geom)
inlineprotectedvirtual

Get ownership of the specified geometry and registers it as global.

Definition at line 265 of file geometry_unit_test_base.h.

References lar::standalone::SetupGeometry().

266  {
267  RegisterGeometry(SharedGeoPtr_t(new_geom));
268  }
virtual void RegisterGeometry(SharedGeoPtr_t new_geom)
Get ownership of the specified geometry and registers it as global.
GeoResources_t::ResourcePtr_t SharedGeoPtr_t
template<typename ConfigurationClass >
fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::ServiceParameters ( std::string  service_name) const
inlineinherited

Returns the configuration of the specified service.

Definition at line 612 of file unit_test_base.h.

References fhicl::ParameterSet::get().

613  {
614  return params.get<fhicl::ParameterSet>(config.ServiceParameterSetPath(service_name));
615  }
fhicl::ParameterSet params
full configuration of the test
Configuration_t config
instance of the configurer
T get(std::string const &key) const
Definition: ParameterSet.h:314
template<typename ConfigurationClass >
void testing::GeometryTesterEnvironment< ConfigurationClass >::Setup ( )
protectedvirtual

The complete initialization, ran at construction by default.

Reimplemented from testing::BasicTesterEnvironment< ConfigurationClass >.

Definition at line 377 of file geometry_unit_test_base.h.

References lar::standalone::SetupGeometry().

378  {
379 
380  //
381  // parse configuration, set up message facility
382  //
384 
385  //
386  // set up the geometry
387  //
388  SetupGeometry();
389 
390  mf::LogInfo("Test") << config.ApplicationName() << " Geometry setup complete.";
391 
392  } // GeometryTesterEnvironment<>::Setup()
MaybeLogger_< ELseverityLevel::ELsev_info, false > LogInfo
ConfigurationClass config
instance of the configurer
virtual void SetupGeometry()
Sets up the geometry (creates and registers it)
virtual void Setup()
The complete initialization, ran at construction by default.
template<typename ConfigurationClass >
void testing::GeometryTesterEnvironment< ConfigurationClass >::SetupGeometry ( )
protectedvirtual

Sets up the geometry (creates and registers it)

Definition at line 363 of file geometry_unit_test_base.h.

364  {
365  //
366  // horrible, shameful hack to support the "new" testing environment
367  // while the old one, informally deprecated, is still around;
368  // we will have TWO versions of GeometryCore around.
369  // Ugh.
370  //
372  // new
373  this->template AcquireProvider<geo::GeometryCore>(CreateNewGeometry());
374  } // GeometryTesterEnvironment<>::SetupGeometry()
virtual void RegisterGeometry(SharedGeoPtr_t new_geom)
Get ownership of the specified geometry and registers it as global.
virtual std::unique_ptr< geo::GeometryCore > CreateNewGeometry() const
Creates a new geometry.
template<typename ConfigurationClass >
void testing::BasicTesterEnvironment< ConfigurationClass >::SetupMessageFacility ( fhicl::ParameterSet const &  pset,
std::string  appl_name = "" 
) const
protectedvirtualinherited

Sets up the message facility.

Sets the message facility up.


Message facility configuration is expected in "services.message" parameter set. If not there, the default configuration is used.

Definition at line 1130 of file unit_test_base.h.

References fhicl::ParameterSet::get_if_present(), MF_LOG_TRACE, mf::SetApplicationName(), mf::SetContextIteration(), mf::SetContextSinglet(), mf::StartMessageFacility(), and fhicl::ParameterSet::to_indented_string().

1133  {
1134  fhicl::ParameterSet mf_pset;
1135 
1136  if (!pset.get_if_present(config.ServiceParameterSetPath("message"), mf_pset)) {
1137  mf_pset = CompileParameterSet(config.DefaultServiceConfiguration("message"));
1138  std::cout << "Using default message facility configuration:\n"
1139  << mf_pset.to_indented_string(1) << std::endl;
1140  } // if no configuration is available
1141 
1142  mf::StartMessageFacility(mf_pset);
1143  if (!appl_name.empty()) mf::SetApplicationName(appl_name);
1144  mf::SetContextIteration("Initialization");
1145  if (options.MessageLevels) {
1146  std::cout << "Printing message levels in 'MessageFacility' category." << std::endl;
1147 
1148  mf::LogProblem("MessageFacility") << "Error messages are shown.";
1149  mf::LogPrint("MessageFacility") << "Warning messages are shown.";
1150  mf::LogVerbatim("MessageFacility") << "Info messages are shown.";
1151  mf::LogTrace("MessageFacility") << "Debug messages are shown.";
1152  MF_LOG_TRACE("MessageFacility")
1153  << "MF_LOG_TRACE/MF_LOG_DEBUG messages are not compiled away.";
1154  } // if print message levels
1155  mf::LogInfo("MessageFacility") << "MessageFacility started.";
1156  mf::SetContextSinglet("main");
1157  } // BasicTesterEnvironment::SetupMessageFacility()
MaybeLogger_< ELseverityLevel::ELsev_info, true > LogVerbatim
Options_t options
options for the test environment
MaybeLogger_< ELseverityLevel::ELsev_info, false > LogInfo
Configuration_t config
instance of the configurer
void SetContextIteration(string const &val)
MaybeLogger_< ELseverityLevel::ELsev_error, true > LogProblem
void StartMessageFacility(fhicl::ParameterSet const &pset, string const &applicationName)
#define MF_LOG_TRACE(id)
std::string to_indented_string() const
bool MessageLevels
print message levels on screen
void SetContextSinglet(string const &val)
MaybeLogger_< ELseverityLevel::ELsev_success, true > LogTrace
static fhicl::ParameterSet CompileParameterSet(std::string cfg)
Compiles a parameter set from a string.
void SetApplicationName(string const &applicationName)
MaybeLogger_< ELseverityLevel::ELsev_warning, true > LogPrint
template<typename ConfigurationClass >
virtual void testing::BasicTesterEnvironment< ConfigurationClass >::SetupMessageFacility ( ) const
inlineprotectedvirtualinherited

Sets up the message facility.

Sets the message facility up.


Message facility configuration is expected in "services.message" parameter set. If not there, the default configuration is used.

Definition at line 659 of file unit_test_base.h.

References lar::standalone::SetupMessageFacility().

660  {
661  SetupMessageFacility(Parameters(), config.ApplicationName());
662  }
fhicl::ParameterSet const & Parameters() const
Returns the full configuration.
Configuration_t config
instance of the configurer
virtual void SetupMessageFacility() const
Sets up the message facility.
template<typename ConfigurationClass >
template<typename Prov , typename... Args>
Prov* testing::TesterEnvironment< ConfigurationClass >::SetupProvider ( Args &&...  args)
inlineinherited

Sets a service provider up by calling its testing::setupProvider()

Template Parameters
Provtype of provider
Argstype of arguments for the setup function
Parameters
argsarguments for the setup function
Returns
a pointer to the provider set up
Exceptions
runtime_errorif the provider already exists
See also
SetupProviderFor(), AcquireProvider()

A provider of type Prov is created, set up and recorded. Provider setup is delegated to testing::setupProvider function specific to the provider itself (that is, testing::setupProvider<Prov>(args...)) to which the setup arguments are forwarded. If the provider already exists, an exception is thrown.

Definition at line 775 of file unit_test_base.h.

References testing::details::CommandLineArguments::args.

776  {
777  if (!providers.setup<Prov>(std::forward<Args>(args)...))
778  throw std::runtime_error("Provider already exists!");
779  return providers.getPointer<Prov>();
780  }
T const * getPointer(std::string label="") const
Retrieve the object of type T stored with the specified label.
Definition: ProviderList.h:357
ProviderList providers
list of available providers
bool setup(Args &&...args)
Construct and register an object of type T with specified arguments.
Definition: ProviderList.h:248
template<typename ConfigurationClass >
template<typename Interface , typename Prov , typename... Args>
Prov* testing::TesterEnvironment< ConfigurationClass >::SetupProviderFor ( Args &&...  args)
inlineinherited

Sets a provider up, recording it as implementation of Interface.

Template Parameters
Interfacetype of provider interface being implemented
Provtype of provider
Argstype of arguments for the setup function
Parameters
argsarguments for the setup function
Returns
a pointer to the provider set up
See also
SetupProvider()

This method performs the same type of setup as SetupProvider(). In addition, it registers the provider as an implementation of Interface. This means that the provider can be obtained not only with provider<Prov>(), which returns a pointer to the actual class Prov, but also as provider<Interface>(), which returns a pointer to the base class Interface.

Definition at line 838 of file unit_test_base.h.

References testing::details::CommandLineArguments::args.

839  {
840  auto prov = SetupProvider<Prov>(std::forward<Args>(args)...);
841  providers.set_alias<Prov, Interface>();
842  return prov;
843  }
ProviderList providers
list of available providers
bool set_alias(std::string alias_label="", std::string prov_label="")
Sets the Alias type as an alias of the Prov provider (with labels)
Definition: ProviderList.h:305
template<typename ConfigurationClass >
template<typename Prov , typename... Args>
Prov* testing::TesterEnvironment< ConfigurationClass >::SetupProviderFromService ( std::string  name,
Args &&...  args 
)
inlineinherited

Sets a service provider up by calling its testing::setupProvider()

Template Parameters
Provtype of provider
Argstype of arguments for the setup function
Parameters
namethe service name (for configuration retrieval)
argsarguments for the setup function
Returns
a pointer to the provider set up
See also
SetupProvider()
Exceptions
runtime_errorif the provider already exists

A provider of type Prov is created, set up and recorded. Provider setup is attempted by constructing the provider with a parameter set from the registered configuration of service with specified name.

Definition at line 797 of file unit_test_base.h.

References testing::details::CommandLineArguments::args.

798  {
799  return SetupProvider<Prov>(this->ServiceParameters(name, std::forward<Args>(args)...));
800  }
fhicl::ParameterSet ServiceParameters(std::string service_name) const
Returns the configuration of the specified service.
template<typename ConfigurationClass >
template<typename Interface , typename Prov , typename... Args>
Prov* testing::TesterEnvironment< ConfigurationClass >::SetupProviderFromServiceFor ( std::string  name,
Args &&...  args 
)
inlineinherited

Sets a provider up, recording it as implementation of Interface.

Template Parameters
Interfacetype of provider interface being implemented
Provtype of provider
Argstype of arguments for the setup function
Parameters
namethe service name (for configuration retrieval)
argsarguments for the setup function
Returns
a pointer to the provider set up
See also
SetupProviderFromService(), SetupProviderFor()
Exceptions
runtime_errorif the provider already exists

This method performs the same type of setup as SetupProviderFromService(). In addition, it registers the provider as an implementation of Interface. This means that the provider can be obtained not only with provider<Prov>(), which returns a pointer to the actual class Prov, but also as provider<Interface>(), which returns a pointer to the base class Interface.

Definition at line 865 of file unit_test_base.h.

References testing::details::CommandLineArguments::args.

866  {
867  auto* prov = SetupProviderFromService<Prov>(name, std::forward<Args>(args)...);
868  providers.set_alias<Prov, Interface>();
869  return prov;
870  }
ProviderList providers
list of available providers
bool set_alias(std::string alias_label="", std::string prov_label="")
Sets the Alias type as an alias of the Prov provider (with labels)
Definition: ProviderList.h:305
template<typename ConfigurationClass >
SharedGeoPtr_t testing::GeometryTesterEnvironment< ConfigurationClass >::SharedGeometry ( ) const
inline

Returns a pointer to the geometry.

Definition at line 243 of file geometry_unit_test_base.h.

243 { return geom; }
SharedGeoPtr_t geom
pointer to the geometry
template<typename ConfigurationClass >
static SharedGeoPtr_t testing::GeometryTesterEnvironment< ConfigurationClass >::SharedGlobalGeometry ( )
inlinestatic

Returns the current global geometry instance (may be nullptr if none)

Definition at line 251 of file geometry_unit_test_base.h.

251 { return GeoResources_t::ShareResource(); }
static ResourcePtr_t ShareResource(std::string name="")
Retrieves the specified resource for sharing (nullptr if none)
template<typename ConfigurationClass >
template<typename Prov >
Prov* testing::TesterEnvironment< ConfigurationClass >::SimpleProviderSetup ( )
inlineinherited

Oversimplified provider setup.

Returns
a pointer to the provider
Template Parameters
Provprovider type

This is a one-step setup of the specified provider.

It is available only if Prov provider comes with an implementation of testing::SimpleEnvironmentSetupClass that explains how to set up an environment.

Definition at line 907 of file unit_test_base.h.

908  {
909  return simpleEnvironmentSetup<Prov>(*this);
910  }
template<typename ConfigurationClass >
fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::TesterParameters ( std::string  test_name) const
inlineinherited

Returns the configuration of the specified test.

Definition at line 618 of file unit_test_base.h.

References fhicl::ParameterSet::get().

619  {
620  return params.get<fhicl::ParameterSet>(config.TesterParameterSetPath(test_name));
621  }
fhicl::ParameterSet params
full configuration of the test
Configuration_t config
instance of the configurer
T get(std::string const &key) const
Definition: ParameterSet.h:314
template<typename ConfigurationClass >
fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::TesterParameters ( ) const
inlineinherited

Returns the configuration of the main test (undefined if no main test)

Definition at line 624 of file unit_test_base.h.

625  {
626  if (config.MainTesterParameterSetName().empty())
627  return {};
628  else
629  return TesterParameters(config.MainTesterParameterSetName());
630  }
Configuration_t config
instance of the configurer
fhicl::ParameterSet TesterParameters() const
Returns the configuration of the main test (undefined if no main test)

Member Data Documentation

template<typename ConfigurationClass >
ConfigurationClass testing::GeometryTesterEnvironment< ConfigurationClass >::config
private

instance of the configurer

Definition at line 275 of file geometry_unit_test_base.h.

template<typename ConfigurationClass >
SharedGeoPtr_t testing::GeometryTesterEnvironment< ConfigurationClass >::geom
private

pointer to the geometry

Definition at line 277 of file geometry_unit_test_base.h.

template<typename ConfigurationClass >
ProviderList testing::TesterEnvironment< ConfigurationClass >::providers
protectedinherited

list of available providers

Definition at line 960 of file unit_test_base.h.


The documentation for this class was generated from the following file: