ProviderPack_test.cc File Reference

#include <boost/test/unit_test.hpp>
#include "larcorealg/CoreUtils/ProviderPack.h"
#include "larcorealg/CoreUtils/UncopiableAndUnmovableClass.h"
#include <string>
#include <ostream>

Go to the source code of this file.

Classes
struct	svc::ProviderA
	A service provider class. More...
struct	svc::ProviderB
	A service provider class. More...
struct	svc::ProviderB1
	A service provider class derived from B. More...
struct	svc::ProviderC
	A service provider class. More...
struct	svc::ProviderD
	A service provider class. More...

Namespaces
	svc

Macros
#define	PROVIDERPACK_TEST_SKIP_COMPILATION_ERRORS   1
#define	BOOST_TEST_MODULE   ( ProviderPack_test )

Functions
	BOOST_AUTO_TEST_CASE (ProviderPack_testcase)
	BOOST_AUTO_TEST_CASE (ProviderPackDerived_testcase)

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( ProviderPack_test )

Definition at line 26 of file ProviderPack_test.cc.

#define PROVIDERPACK_TEST_SKIP_COMPILATION_ERRORS   1

Definition at line 13 of file ProviderPack_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

ProviderPack_testcase

)

Definition at line 114 of file ProviderPack_test.cc.

                                            {

  // instantiate a ProviderPack with three classes
  svc::ProviderA providerA;
  svc::ProviderB providerB;
  svc::ProviderC providerC;
  auto SP1 = lar::makeProviderPack(&providerA, &providerB, &providerC);

  // get element A
  static_assert
    (decltype(SP1)::has<svc::ProviderA>(), "We don't believe to have ProviderA!!");
  auto myA = SP1.get<svc::ProviderA>();
  static_assert(std::is_same<decltype(myA), svc::ProviderA const*>(),
    "Failed to get the element of type A");
  BOOST_TEST(myA == &providerA);

  // get element B
  static_assert
    (decltype(SP1)::has<svc::ProviderB>(), "We don't believe to have ProviderB!!");
  auto myB = SP1.get<svc::ProviderB>();
  static_assert(std::is_same<decltype(myB), svc::ProviderB const*>(),
    "Failed to get the element of type B");
  BOOST_TEST(myB == &providerB);

  // get element C
  static_assert
    (decltype(SP1)::has<svc::ProviderC>(), "We don't believe to have ProviderC!!");
  auto myC = SP1.get<svc::ProviderC>();
  static_assert(std::is_same<decltype(myC), svc::ProviderC const*>(),
    "Failed to get the element of type C");
  BOOST_TEST(myC == &providerC);


  // set element A
  svc::ProviderA providerA2;
  SP1.set(&providerA2);
  myA = SP1.get<svc::ProviderA>();
  BOOST_TEST(myA == &providerA2);

  // get element D
  // should be a compilation error
#if PROVIDERPACK_TEST_SKIP_COMPILATION_ERRORS
  BOOST_TEST_MESSAGE("  (test to get a non-existing provider type skipped)");
#else
  SP1.get<svc::ProviderD>();
#endif // !PROVIDERPACK_TEST_SKIP_COMPILATION_ERRORS

  // check what we believe we have
  static_assert
    (!decltype(SP1)::has<svc::ProviderD>(), "We believe to have ProviderD!!");

  // default constructor: all null
  lar::ProviderPack<svc::ProviderA, svc::ProviderB> SP2;
  BOOST_TEST(SP2.get<svc::ProviderA>() == nullptr);
  BOOST_TEST(SP2.get<svc::ProviderB>() == nullptr);

  // extraction constructor
  lar::ProviderPack<svc::ProviderA, svc::ProviderB> SP3(SP1);
  BOOST_TEST(SP3.get<svc::ProviderA>() == SP1.get<svc::ProviderA>());
  BOOST_TEST(SP3.get<svc::ProviderB>() == SP1.get<svc::ProviderB>());

  // multiple elements of the same type
  // should be a compilation error
#if PROVIDERPACK_TEST_SKIP_COMPILATION_ERRORS
  BOOST_TEST_MESSAGE
    ("  (test to create a pack with many providers with same type skipped)");
#else
  lar::ProviderPack
    <svc::ProviderA, svc::ProviderB, svc::ProviderA, svc::ProviderD> SP3;
#endif // !PROVIDERPACK_TEST_SKIP_COMPILATION_ERRORS


} // BOOST_AUTO_TEST_CASE(ProviderPack_testcase)

BOOST_AUTO_TEST_CASE

(

ProviderPackDerived_testcase

)

Definition at line 190 of file ProviderPack_test.cc.

                                                   {

  svc::ProviderA providerA;
  svc::ProviderB1 providerB;

  //
  // initialise a base class provider with a derived class
  //
  lar::ProviderPack<svc::ProviderA, svc::ProviderB> SP1
    (&providerA, &providerB);

  BOOST_TEST(SP1.get<svc::ProviderA>() == &providerA);
  BOOST_TEST(SP1.get<svc::ProviderB>() == &providerB);

  //
  // initialise with a copy from makeProviderPack(),
  // which should return lar::ProviderPack<svc::ProviderA, svc::ProviderB1>
  //
  lar::ProviderPack<svc::ProviderA, svc::ProviderB> SP2
    = makeProviderPack(&providerA, &providerB);

  BOOST_TEST(SP2.get<svc::ProviderA>() == &providerA);
  BOOST_TEST(SP2.get<svc::ProviderB>() == &providerB);

} // BOOST_AUTO_TEST_CASE(test_ProviderPack)