testing::BasicTesterEnvironment< ConfigurationClass > Class Template Reference

Environment for a test. More...

#include <unit_test_base.h>

Inheritance diagram for testing::BasicTesterEnvironment< ConfigurationClass >:

Classes
struct	Options_t
	Test environment options. More...

Public Types
using	Configuration_t = ConfigurationClass

Public Member Functions
	BasicTesterEnvironment (bool bSetup=true)
	Constructor: sets everything up and declares the test started. More...
virtual	~BasicTesterEnvironment ()
	Destructor: closing remarks. More...
	BasicTesterEnvironment (Configuration_t const &configurer, bool bSetup=true)
	Setup from a configuration. More...
	BasicTesterEnvironment (Configuration_t &&configurer, bool bSetup=true)
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 fhicl::ParameterSet	CompileParameterSet (std::string cfg)
	Compiles a parameter set from a string. More...

Protected Member Functions
Configuration_t const &	Config () const
	Returns a read-only version of the configuration. More...
virtual void	Setup ()
	The complete initialization, ran at construction by default. 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	SetupMessageFacility (fhicl::ParameterSet const &pset, std::string appl_name="") const
	Sets up the message facility. More...
virtual void	SetupMessageFacility () const

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

Private Member Functions
void	ParseEnvironmentOptions ()
	Parses the configuration, looking for the test environment options. More...

Private Attributes
Configuration_t	config
	instance of the configurer More...
Options_t	options
	options for the test environment More...
fhicl::ParameterSet	params
	full configuration of the test More...

Detailed Description

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

Environment for a test.

---

Template Parameters

ConfigurationClass

a class providing compile-time configuration

The test environment is set up on construction.

The environment provides:

• Parameters() method returning the complete FHiCL configuration
• TesterParameters() method returning the configuration for the test

This class or a derived one can be used as global fixture for unit tests.

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 BasicTesterEnvironment uses to get its parameters.

The requirements for the ConfigurationClass are:

• std::string ApplicationName(): the application name
• std::string ConfigurationPath(): path to the configuration file
• std::string MainTesterParameterSetName(): name of the configuration of the main test (commodity)
• 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 (BasicTesterEnvironment<ConfigurationClass>(no_setup))

Definition at line 560 of file unit_test_base.h.

Member Typedef Documentation

template<typename ConfigurationClass>

using testing::BasicTesterEnvironment< ConfigurationClass >::Configuration_t = ConfigurationClass

Definition at line 563 of file unit_test_base.h.

Constructor & Destructor Documentation

template<typename ConfigurationClass>

testing::BasicTesterEnvironment< ConfigurationClass >::BasicTesterEnvironment ( bool  bSetup = true )

inline

Constructor: sets everything up and declares the test started.

Parameters

bSetup

(default: true) call Setup() after construction

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

Definition at line 572 of file unit_test_base.h.

{ if (bSetup) Setup(); }

template<typename ConfigurationClass>

testing::BasicTesterEnvironment< ConfigurationClass >::BasicTesterEnvironment ( Configuration_t const &  configurer, bool  bSetup = true  )

inline

Setup from a configuration.

Parameters

configurer	an instance of ConfigurationClass
bSetup	(default: true) call Setup() after construction

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 589 of file unit_test_base.h.

                                                             :
      config(configurer)
      { if (bSetup) Setup(); }

template<typename ConfigurationClass>

testing::BasicTesterEnvironment< ConfigurationClass >::BasicTesterEnvironment ( Configuration_t &&  configurer, bool  bSetup = true  )

inline

Definition at line 592 of file unit_test_base.h.

                                                                            :
      config(configurer)
      { if (bSetup) Setup(); }

template<typename ConfigurationClass >

testing::BasicTesterEnvironment< ConfigurationClass >::~BasicTesterEnvironment ( )

virtual

Destructor: closing remarks.

Definition at line 1071 of file unit_test_base.h.

                                                                      {

    mf::LogInfo("Test") << config.ApplicationName() << " completed.";

  } // BasicTesterEnvironment<>::~BasicTesterEnvironment()

Member Function Documentation

template<typename ConfigurationClass >

fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::CompileParameterSet ( std::string  cfg )

static

Compiles a parameter set from a string.

---

Returns

a parameters set with the complete configuration

Definition at line 1085 of file unit_test_base.h.

  {
    fhicl::ParameterSet global_pset;
    global_pset = fhicl::ParameterSet::make(cfg);
    return global_pset;
  } // BasicTesterEnvironment<>::CompileParameterSet()

template<typename ConfigurationClass>

Configuration_t const& testing::BasicTesterEnvironment< ConfigurationClass >::Config ( ) const

inlineprotected

Returns a read-only version of the configuration.

Definition at line 635 of file unit_test_base.h.

{ return config; }

template<typename ConfigurationClass >

void testing::BasicTesterEnvironment< ConfigurationClass >::Configure ( )

protectedvirtual

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 1135 of file unit_test_base.h.

                                                             {
    std::string config_path = config.ConfigurationPath();
    params = config_path.empty()?
      DefaultParameters(): ParseParameters(config_path);
  } // BasicTesterEnvironment::Configure()

template<typename ConfigurationClass>

virtual fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::DefaultParameters ( ) const

inlineprotectedvirtual

Creates a full configuration for the test.

Returns

a parameters set with the complete configuration

Definition at line 647 of file unit_test_base.h.

      { return CompileParameterSet(config.DefaultConfiguration()); }

template<typename ConfigurationClass>

fhicl::ParameterSet const& testing::BasicTesterEnvironment< ConfigurationClass >::Parameters ( ) const

inline

Returns the full configuration.

Definition at line 605 of file unit_test_base.h.

{ return params; }

template<typename ConfigurationClass >

void testing::BasicTesterEnvironment< ConfigurationClass >::ParseEnvironmentOptions ( )

private

Parses the configuration, looking for the test environment options.

Definition at line 1221 of file unit_test_base.h.

                                                                           {

    struct OptionsFromConfig_t {
      fhicl::Atom<bool> messageLevels{
        fhicl::Name("messageLevels"),
        fhicl::Comment("prints a message per level (to verify the visible ones"),
        false // default: no
        };
      fhicl::Atom<bool> printOptions{
        fhicl::Name("printOptions"),
        fhicl::Comment("prints a the list of options (this is one of them!)"),
        false // default: no
        };
    }; // OptionsFromConfig_t


    struct ValidationHelper {
      static void printDummy(std::ostream& out)
        {
          fhicl::Table<OptionsFromConfig_t>
            (fhicl::Name("test"), fhicl::Comment("Test environment options"))
            .print_allowed_configuration(out);
        } // printDummy()

      static fhicl::Table<OptionsFromConfig_t> validate
        (fhicl::ParameterSet const& pset)
        {
          try {
            return fhicl::Table<OptionsFromConfig_t>(pset, {});
          }
          catch (...) {
            std::cerr << "Error parsing environment test options! Valid options:"
              << std::endl;
            ValidationHelper::printDummy(std::cerr);
            throw;
          }
        } // validate()
    };


    fhicl::ParameterSet pset = params.get<fhicl::ParameterSet>("test", {});

    // automatically performs validation
    fhicl::Table<OptionsFromConfig_t> configTable
      (ValidationHelper::validate(pset));

    if (configTable().printOptions()) {
      std::cout
        << "The following options can be passed to the test environment"
        << " by putting them in the \"test: {}\" table of the configuration file:"
        << std::endl;
      ValidationHelper::printDummy(std::cout);
    }

    options.MessageLevels = configTable().messageLevels();

  } // BasicTesterEnvironment<>::ParseEnvironmentOptions()

template<typename ConfigurationClass >

fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::ParseParameters ( std::string  config_path )

staticprotected

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_path

full path of the FHiCL configuration file

Returns

a parameters set with the complete configuration from the file

Definition at line 1101 of file unit_test_base.h.

  {
    // configuration file lookup policy
    char const* fhicl_env = getenv("FHICL_FILE_PATH");
    std::string search_path = fhicl_env? std::string(fhicl_env) + ":": ".:";
    details::FirstAbsoluteOrLookupWithDotPolicy policy(search_path);

    // parse a configuration file; obtain intermediate form
    fhicl::intermediate_table table;
    table = fhicl::parse_document(config_path, policy);

    // translate into a parameter set
    fhicl::ParameterSet global_pset;
    global_pset = fhicl::ParameterSet::make(table);

    return global_pset;
  } // BasicTesterEnvironment<>::ParseParameters()

template<typename ConfigurationClass>

fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::ServiceParameters ( std::string  service_name ) const

inline

Returns the configuration of the specified service.

Definition at line 608 of file unit_test_base.h.

      {
        return params.get<fhicl::ParameterSet>
          (config.ServiceParameterSetPath(service_name));
      }

template<typename ConfigurationClass >

void testing::BasicTesterEnvironment< ConfigurationClass >::Setup ( )

protectedvirtual

The complete initialization, ran at construction by default.

Reimplemented in testing::GeometryTesterEnvironment< ConfigurationClass >, testing::GeometryTesterEnvironment< IcarusGeometryConfiguration >, testing::GeometryTesterEnvironment< SBNDGeometryConfiguration >, and testing::GeometryTesterEnvironment< StandardGeometryConfiguration >.

Definition at line 1184 of file unit_test_base.h.

    {

    //
    // get the configuration
    //
    Configure();

    //
    // parse the options specific to the test environment
    //
    ParseEnvironmentOptions();

    //
    // set up the message facility
    //
    SetupMessageFacility();

    //
    // Optionally print the configuration
    //
    {
      mf::LogInfo msg("Configuration");
      msg << "Complete configuration (";
      if (config.ConfigurationPath().empty()) msg << "default";
      else msg << "'" << config.ConfigurationPath() << "'";
      msg << "):\n" << Parameters().to_indented_string(1);
    }


    mf::LogInfo("Test") << config.ApplicationName() << " base setup complete.";

  } // BasicTesterEnvironment<>::Setup()

template<typename ConfigurationClass >

void testing::BasicTesterEnvironment< ConfigurationClass >::SetupMessageFacility ( fhicl::ParameterSet const &  pset, std::string  appl_name = ""  ) const

protectedvirtual

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 1150 of file unit_test_base.h.

  {
    fhicl::ParameterSet mf_pset;

    if
      (!pset.get_if_present(config.ServiceParameterSetPath("message"), mf_pset))
    {
      mf_pset
        = CompileParameterSet(config.DefaultServiceConfiguration("message"));
      std::cout << "Using default message facility configuration:\n"
        << mf_pset.to_indented_string(1) << std::endl;
    } // if no configuration is available

    mf::StartMessageFacility(mf_pset);
    if (!appl_name.empty()) mf::SetApplicationName(appl_name);
    mf::SetContextIteration("Initialization");
    if (options.MessageLevels) {
      std::cout << "Printing message levels in 'MessageFacility' category."
        << std::endl;

      mf::LogProblem("MessageFacility") << "Error messages are shown.";
      mf::LogPrint("MessageFacility") << "Warning messages are shown.";
      mf::LogVerbatim("MessageFacility") << "Info messages are shown.";
      mf::LogTrace("MessageFacility") << "Debug messages are shown.";
      MF_LOG_TRACE("MessageFacility")
        << "MF_LOG_TRACE/MF_LOG_DEBUG messages are not compiled away.";
    } // if print message levels
    mf::LogInfo("MessageFacility") << "MessageFacility started.";
    mf::SetContextSinglet("main");
  } // BasicTesterEnvironment::SetupMessageFacility()

template<typename ConfigurationClass>

virtual void testing::BasicTesterEnvironment< ConfigurationClass >::SetupMessageFacility ( ) const

inlineprotectedvirtual

Definition at line 654 of file unit_test_base.h.

      { SetupMessageFacility(Parameters(), config.ApplicationName()); }

template<typename ConfigurationClass>

fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::TesterParameters ( std::string  test_name ) const

inline

Returns the configuration of the specified test.

Definition at line 615 of file unit_test_base.h.

      {
        return params.get<fhicl::ParameterSet>
          (config.TesterParameterSetPath(test_name));
      }

template<typename ConfigurationClass>

fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::TesterParameters ( ) const

inline

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

Definition at line 622 of file unit_test_base.h.

      {
        if (config.MainTesterParameterSetName().empty()) return {};
        else return TesterParameters(config.MainTesterParameterSetName());
      }

Member Data Documentation

template<typename ConfigurationClass>

Configuration_t testing::BasicTesterEnvironment< ConfigurationClass >::config

private

instance of the configurer

Definition at line 674 of file unit_test_base.h.

template<typename ConfigurationClass>

Options_t testing::BasicTesterEnvironment< ConfigurationClass >::options

private

options for the test environment

Definition at line 675 of file unit_test_base.h.

template<typename ConfigurationClass>

fhicl::ParameterSet testing::BasicTesterEnvironment< ConfigurationClass >::params

private

full configuration of the test

Definition at line 680 of file unit_test_base.h.

---

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

• unit_test_base.h