ProviderList_test.cc File Reference

#include "larcorealg/TestUtils/ProviderList.h"
#include <boost/test/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_TEST(l->setup<NormalDatumClass>(12));
   BOOST_TEST(l->setup_instance<UncopiableDatumClass>("One", "uncopiable"));
   BOOST_TEST(l->setup<UnmovableDatumClass>());
   BOOST_TEST
     (l->custom_setup<PinnedDatumClass>(&PinnedDatumClass::New, 1.0, 0.0));
   BOOST_TEST((l->set_alias<PinnedDatumClass, PinnedDatumClassBase>()));

   // second creation shoudl fail
   BOOST_TEST(!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_TEST(TrackedMemory.empty());

   // check that we noticed a single call for a custom setup
   BOOST_TEST(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_TEST(
     l.acquire(std::make_unique<UncopiableDatumClass>
       ("another uncopiable"), "Acquired")
     );
   TestElement<UncopiableDatumClass>(l, "Acquired", true);

   // erase it
   BOOST_TEST(l.erase<UncopiableDatumClass>("Acquired"));
   TestElement<UncopiableDatumClass>(l, "Acquired", false);

   // erase it again
   BOOST_TEST(!l.erase<UncopiableDatumClass>("Acquired"));
   TestElement<UncopiableDatumClass>(l, "Acquired", false);

   // erase something that was never there
   BOOST_TEST(!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_TEST(!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_TEST(l.template known<T>(label) == present);
   BOOST_TEST(l.template valid<T>(label) == present);
   try {
      auto const& item = l.template get<T>(label);
      BOOST_TEST(present); // if not present, we should not be here!
      BOOST_TEST(&item);
   }
   catch (testing::ProviderList::provider_not_available const& e) {
      BOOST_TEST(!present); // if present, we should not be here!
   }

} // TestElement()

Variable Documentation

std::set<void*> TrackedMemory

Definition at line 27 of file ProviderList_test.cc.