associated_groups_test.cc File Reference

Unit test for util::associated_groups(). More...

#include "lardata/Utilities/ForEachAssociatedGroup.h"
#include "canvas/Persistency/Provenance/ProductID.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/Assns.h"
#include "boost/test/unit_test.hpp"
#include <array>
#include <iostream>
#include "TROOT.h"
#include "TInterpreter.h"
#include "TClassEdit.h"
#include <string>
#include <typeinfo>

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   ( PointIsolationAlg_test )

Functions
template<typename T >
TClass *	QuickGenerateTClass ()
void	AssociatedGroupsTest ()
	BOOST_AUTO_TEST_CASE (AssociatedGroupsTestCase)

Detailed Description

Unit test for util::associated_groups().

Author

Gianluca Petrillo (petri.nosp@m.llo@.nosp@m.fnal..nosp@m.gov)

Date

February 7th, 2017

Definition in file associated_groups_test.cc.

Macro Definition Documentation

#define BOOST_TEST_MODULE   ( PointIsolationAlg_test )

Definition at line 18 of file associated_groups_test.cc.

Function Documentation

void AssociatedGroupsTest

(

)

Definition at line 60 of file associated_groups_test.cc.

                            {

  // types used in the association (they actually do not matter)
  struct TypeA {};
  struct TypeB {};

  using MyAssns_t = art::Assns<TypeA, TypeB>;

  // art::Assns constructor tries to have ROOT initialise its streamer, which
  // requires a TClass instance which is not present at this time.
  // This trick creates that TClass.
  QuickGenerateTClass<MyAssns_t>();

  using Index_t = art::Ptr<TypeA>::key_type;

  // association description: B's for each A
  std::array<std::pair<Index_t, std::vector<Index_t>>, 3U> expected;
  expected[0] = { 0, { 0, 3, 6 } };
  expected[1] = { 1, { 2, 4, 6 } };
  expected[2] = { 3, { 8, 10, 12, 13 } };
  art::ProductID aPID{ 5 }, bPID{ 12 };

  // fill the association
  MyAssns_t assns;
  for (auto const& pair: expected) {
    auto const& aIndex = pair.first;
    for (auto const& bIndex: pair.second) {
      assns.addSingle({ aPID, aIndex, nullptr }, { bPID, bIndex, nullptr });
    } // for bIndex
  } // for pair

  std::vector<std::vector<Index_t>> results;
  for (auto Bs: util::associated_groups(assns)) {
    std::cout << "Association group #" << results.size() << ":" << std::endl;
    results.emplace_back();
    std::vector<Index_t>& myBs = results.back();
    for(art::Ptr<TypeB> const& B: Bs) {
      std::cout << "  " << B << std::endl;
      myBs.push_back(B.key());
    }
  } // for associated groups

  //strings should be same as vs
  std::cout << "Starting check..." << std::endl;
  BOOST_TEST(results.size() == expected.size());
  for (size_t i = 0; i < results.size(); ++i) {
    auto const& Bs = results[i];
    auto const& expectedBs = expected[i].second;
    BOOST_TEST_MESSAGE("  element #" << i << ", A=" << expected[i].first);
    BOOST_TEST(Bs.size() == expectedBs.size());
    for (size_t j = 0; j < expectedBs.size(); ++j) {
      BOOST_TEST_MESSAGE("    assn #" << j);
      BOOST_TEST(Bs[j] == expectedBs[j]);
    } // for j
  } // for results

} // associated_groups_test()

BOOST_AUTO_TEST_CASE

(

AssociatedGroupsTestCase

)

Definition at line 122 of file associated_groups_test.cc.

                                               {
  AssociatedGroupsTest();
} // AssociatedGroupsTestCase

template<typename T >

TClass* QuickGenerateTClass

(

)

Definition at line 37 of file associated_groups_test.cc.

                              {

  // magic! this interpreter call is needed before GetNormalizedName() is called
  TInterpreter* interpreter = gROOT->GetInterpreter();

  // demangle name of type T
  int err; // we'll ignore errors
  char* classNameC = TClassEdit::DemangleTypeIdName(typeid(T), err);

  // "normalise" it
  std::string normalizedClassName;
  TClassEdit::GetNormalizedName(normalizedClassName, classNameC);

  // clean up
  std::free(classNameC);

  // generate and register the TClass; load it and be silent.
  return interpreter->GenerateTClass(normalizedClassName.c_str(), kTRUE, kTRUE);

} // QuickGenerateTClass()