ProviderList_test.cc File Reference

#include "TestUtils/ProviderList.h"
#include <cetlib/quiet_unit_test.hpp>
#include <set>
#include <memory>

Go to the source code of this file.

Classes
struct	NormalDatumClass
struct	UncopiableDatumClass
struct	UnmovableDatumClass
struct	PinnedDatumClassBase
struct	PinnedDatumClass

Namespaces
	testing
	LArSoft test utilities.

Macros
#define	BOOST_TEST_MODULE   ProviderList_test

Functions
template<>
std::unique_ptr< UnmovableDatumClass >	testing::setupProvider< UnmovableDatumClass > ()
template<typename T , typename LIST >
void	TestElement (LIST &l, std::string label="", bool present=true)
template<typename LIST >
void	TestBase (LIST &l)
void	ConstTest (testing::ProviderList const &l)
void	NonConstTest (testing::ProviderList &l)
	BOOST_AUTO_TEST_CASE (ProviderListTest)

Variables
std::set< void * >	TrackedMemory

Macro Definition Documentation

#define BOOST_TEST_MODULE   ProviderList_test

Definition at line 17 of file ProviderList_test.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

ProviderListTest

)

Definition at line 186 of file ProviderList_test.cc.

{
   BOOST_TEST_MESSAGE("Construction and instantiation of ProviderList");
   auto l = std::make_unique<testing::ProviderList>();
   
   BOOST_CHECK(l->setup<NormalDatumClass>(12));
   BOOST_CHECK(l->setup_instance<UncopiableDatumClass>("One", "uncopiable"));
   BOOST_CHECK(l->setup<UnmovableDatumClass>());
   BOOST_CHECK
     (l->custom_setup<PinnedDatumClass>(&PinnedDatumClass::New, 1.0, 0.0));
   BOOST_CHECK((l->set_alias<PinnedDatumClass, PinnedDatumClassBase>()));
   
   // second creation shoudl fail
   BOOST_CHECK(!l->setup_instance<UncopiableDatumClass>("One", "uncopiableII"));
   
   BOOST_TEST_MESSAGE("Constant list test");
   ConstTest(*l);
   BOOST_TEST_MESSAGE("Mutable list test");
   NonConstTest(*l);
   
   BOOST_TEST_MESSAGE("ProviderListTest completed");   
   
   // make sure that we did not leak anything
   l.reset();
   BOOST_CHECK(TrackedMemory.empty());
   
   // check that we noticed a single call for a custom setup
   BOOST_CHECK_EQUAL(PinnedDatumClass::nNewCalls, 1U);
   
} // BOOST_AUTO_TEST_CASE(ProviderListTest)

void ConstTest

(

testing::ProviderList const &

l

)

Definition at line 154 of file ProviderList_test.cc.

{ TestBase(l); }

void NonConstTest

(

testing::ProviderList &

l

)

Definition at line 155 of file ProviderList_test.cc.

                                          {
   TestBase(l);
   
   // check that no "Acquired" is available yet
   TestElement<UncopiableDatumClass>(l, "Acquired", false);
   
   // acquire a new one
   BOOST_CHECK(
     l.acquire(std::make_unique<UncopiableDatumClass>
       ("another uncopiable"), "Acquired")
     );
   TestElement<UncopiableDatumClass>(l, "Acquired", true);
   
   // erase it
   BOOST_CHECK(l.erase<UncopiableDatumClass>("Acquired"));
   TestElement<UncopiableDatumClass>(l, "Acquired", false);
   
   // erase it again
   BOOST_CHECK(!l.erase<UncopiableDatumClass>("Acquired"));
   TestElement<UncopiableDatumClass>(l, "Acquired", false);
     
   // erase something that was never there
   BOOST_CHECK(!l.erase<UncopiableDatumClass>("Never"));
   TestElement<UncopiableDatumClass>(l, "Never", false);
     
} // NonConstTest()

template<typename LIST >

void TestBase

(

LIST &

l

)

Definition at line 137 of file ProviderList_test.cc.

                       {
   
   TestElement<NormalDatumClass>(l);
   TestElement<UncopiableDatumClass>(l, "", false); // empty label not present
   TestElement<UncopiableDatumClass>(l, "One"); // label "One" present
   TestElement<UncopiableDatumClass>(l, "Two", false); // label "Two" not there
   TestElement<UnmovableDatumClass>(l);
   TestElement<PinnedDatumClass>(l);
   TestElement<PinnedDatumClassBase>(l);
   TestElement<int>(l, "", false); // no int present
   
   // test that the polymorphism is preserved by aliases
   BOOST_CHECK(!l.template get<PinnedDatumClassBase>().abstract());
   
} // TestBase()

template<typename T , typename LIST >

void TestElement	(	LIST &	l,
		std::string	label = "",
		bool	present = true
	)

Definition at line 118 of file ProviderList_test.cc.

                                                                     {
   
   BOOST_TEST_MESSAGE("Testing class '" << typeid(T).name() << "' label \""
     << label << "\" (" << (present? "present": "not present") << ")" );
   BOOST_CHECK_EQUAL(l.template known<T>(label), present);
   BOOST_CHECK_EQUAL(l.template valid<T>(label), present);
   try {
      auto const& item = l.template get<T>(label);
      BOOST_CHECK(present); // if not present, we should not be here!
      BOOST_CHECK(&item);
   }
   catch (testing::ProviderList::provider_not_available const& e) {
      BOOST_CHECK(!present); // if present, we should not be here!
   }
   
} // TestElement()

Variable Documentation

std::set<void*> TrackedMemory

Definition at line 27 of file ProviderList_test.cc.