Event_t.cc File Reference

#include "boost/test/unit_test.hpp"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/EventPrincipal.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Principal/RunPrincipal.h"
#include "art/Framework/Principal/Selector.h"
#include "art/Framework/Principal/SubRunPrincipal.h"
#include "art/Persistency/Provenance/ModuleContext.h"
#include "art/Persistency/Provenance/ModuleDescription.h"
#include "art/Persistency/Provenance/ModuleType.h"
#include "art/Persistency/Provenance/ProcessHistoryRegistry.h"
#include "art/Version/GetReleaseVersion.h"
#include "art/test/TestObjects/ToyProducts.h"
#include "canvas/Persistency/Common/WrappedTypeID.h"
#include "canvas/Persistency/Provenance/BranchDescription.h"
#include "canvas/Persistency/Provenance/EventAuxiliary.h"
#include "canvas/Persistency/Provenance/EventID.h"
#include "canvas/Persistency/Provenance/History.h"
#include "canvas/Persistency/Provenance/ProcessHistory.h"
#include "canvas/Persistency/Provenance/ProductTables.h"
#include "canvas/Persistency/Provenance/RunAuxiliary.h"
#include "canvas/Persistency/Provenance/SubRunAuxiliary.h"
#include "canvas/Persistency/Provenance/Timestamp.h"
#include "canvas/Persistency/Provenance/TypeLabel.h"
#include "canvas/Utilities/InputTag.h"
#include "cetlib/container_algorithms.h"
#include "fhiclcpp/ParameterSet.h"
#include <algorithm>
#include <fstream>
#include <iterator>
#include <map>
#include <memory>
#include <string>
#include <typeinfo>
#include <utility>
#include <vector>

Go to the source code of this file.

Classes
class	art::EDProducer
class	ProductTablesFixture
struct	EventTestFixture

Namespaces
	art

Macros
#define	BOOST_TEST_MODULE   (Event_t)

Typedefs
using	product_t = arttest::IntProduct

Functions
std::ostream &	art::boost_test_print_type (std::ostream &os, Timestamp const timestamp)
	BOOST_AUTO_TEST_CASE (badProductID)
	BOOST_AUTO_TEST_CASE (emptyEvent)
	BOOST_AUTO_TEST_CASE (getBySelectorFromEmpty)
	BOOST_AUTO_TEST_CASE (dereferenceDfltHandle)
	BOOST_AUTO_TEST_CASE (putAnIntProduct)
	BOOST_AUTO_TEST_CASE (putAndGetAnIntProduct)
	BOOST_AUTO_TEST_CASE (getByProductID)
	BOOST_AUTO_TEST_CASE (transaction)
	BOOST_AUTO_TEST_CASE (getProductTokens)
	BOOST_AUTO_TEST_CASE (getByInstanceName)
	BOOST_AUTO_TEST_CASE (getBySelector)
	BOOST_AUTO_TEST_CASE (getByLabel)
	BOOST_AUTO_TEST_CASE (getByLabelSpecialProcessNames)
	BOOST_AUTO_TEST_CASE (getManyByType)
	BOOST_AUTO_TEST_CASE (printHistory)

Macro Definition Documentation

#define BOOST_TEST_MODULE   (Event_t)

Definition at line 2 of file Event_t.cc.

Typedef Documentation

using product_t = arttest::IntProduct

Definition at line 61 of file Event_t.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

badProductID

)

Definition at line 341 of file Event_t.cc.

{
  auto const pid = ProductID::invalid();
  InputTag tag{};
  if (auto pd = currentEvent_->getProductDescription(pid)) {
    tag = pd->inputTag();
  }
  BOOST_TEST(tag.empty());
}

BOOST_AUTO_TEST_CASE

(

emptyEvent

)

Definition at line 351 of file Event_t.cc.

{
  BOOST_TEST_REQUIRE(currentEvent_.get());
  BOOST_TEST(currentEvent_->id() == make_id());
  BOOST_TEST(currentEvent_->time() == make_timestamp());
}

BOOST_AUTO_TEST_CASE

(

getBySelectorFromEmpty

)

Definition at line 358 of file Event_t.cc.

{
  ModuleLabelSelector const byModuleLabel{"mod1"};
  Handle<int> nonesuch;
  BOOST_TEST(not nonesuch);
  BOOST_TEST(!nonesuch.isValid());
  BOOST_TEST(!currentEvent_->get(byModuleLabel, nonesuch));
  BOOST_TEST(!nonesuch.isValid());
  BOOST_TEST(nonesuch.failedToGet());
  BOOST_CHECK_THROW(*nonesuch, cet::exception);
}

BOOST_AUTO_TEST_CASE

(

dereferenceDfltHandle

)

Definition at line 370 of file Event_t.cc.

{
  Handle<int> nonesuch;
  BOOST_CHECK_THROW(*nonesuch, cet::exception);
  BOOST_CHECK_THROW(nonesuch.product(), cet::exception);
}

BOOST_AUTO_TEST_CASE

(

putAnIntProduct

)

Definition at line 377 of file Event_t.cc.

{
  currentEvent_->put(product_with_value(3), "int1");
  EDProducer::commitEvent(*principal_, *currentEvent_);
}

BOOST_AUTO_TEST_CASE

(

putAndGetAnIntProduct

)

Definition at line 383 of file Event_t.cc.

{
  currentEvent_->put(product_with_value(4), "int1");
  EDProducer::commitEvent(*principal_, *currentEvent_);

  ProcessNameSelector const should_match{"CURRENT"};
  ProcessNameSelector const should_not_match{"NONESUCH"};
  // The ProcessNameSelector does not understand the "current_process"
  // string.  See notes in the Selector header file.
  ProcessNameSelector const should_also_not_match{"current_process"};
  Handle<arttest::IntProduct> h;
  BOOST_TEST_REQUIRE(currentEvent_->get(should_match, h));
  BOOST_TEST(h);
  BOOST_TEST(h.isValid());
  h.clear();
  BOOST_CHECK_THROW(*h, cet::exception);
  BOOST_TEST_REQUIRE(!currentEvent_->get(should_not_match, h));
  BOOST_TEST(!h.isValid());
  BOOST_CHECK_THROW(*h, cet::exception);
  BOOST_TEST_REQUIRE(!currentEvent_->get(should_also_not_match, h));
  BOOST_TEST(!h.isValid());
  BOOST_CHECK_THROW(*h, cet::exception);
}

BOOST_AUTO_TEST_CASE

(

getByProductID

)

Definition at line 407 of file Event_t.cc.

{
  using handle_t = Handle<product_t>;

  ProductID wanted;
  {
    auto const id1 =
      addSourceProduct(product_with_value(1), "int1_tag", "int1");
    BOOST_TEST(id1 != ProductID{});
    wanted = id1;

    auto const id2 =
      addSourceProduct(product_with_value(2), "int2_tag", "int2");
    BOOST_TEST(id2 != ProductID{});
    BOOST_TEST(id2 != id1);
  }
  Handle<arttest::IntProduct> h;
  currentEvent_->get(wanted, h);
  BOOST_TEST(h.isValid());
  BOOST_TEST(h.id() == wanted);
  BOOST_TEST(h->value == 1);

  ProductID const notpresent{};
  BOOST_TEST_REQUIRE(!currentEvent_->get(notpresent, h));
  BOOST_TEST(!h.isValid());
  BOOST_TEST(h.failedToGet());
  BOOST_CHECK_THROW(*h, cet::exception);
}

BOOST_AUTO_TEST_CASE

(

transaction

)

Definition at line 436 of file Event_t.cc.

{
  // Put a product into an Event, and make sure that if we don't
  // movePutProductsToPrincipal, there is no product in the EventPrincipal
  // afterwards.
  BOOST_TEST(principal_->size() == 6u);
  currentEvent_->put(product_with_value(3), "int1");
  BOOST_TEST(principal_->size() == 6u);
}

BOOST_AUTO_TEST_CASE

(

getProductTokens

)

Definition at line 446 of file Event_t.cc.

{
  addSourceProduct(product_with_value(1), "int1_tag", "int1");
  addSourceProduct(product_with_value(2), "int2_tag", "int2");
  addSourceProduct(product_with_value(3), "int3_tag");
  addSourceProduct(product_with_value(4), "nolabel_tag");

  auto const tags = currentEvent_->getInputTags<product_t>();
  auto const tokens = currentEvent_->getProductTokens<product_t>();
  BOOST_TEST(size(tags) == size(tokens));

  // Verify that the same products are retrieved whether tags or
  // tokens are used.
  for (std::size_t i{}; i < tags.size(); ++i) {
    auto h1 = currentEvent_->getHandle<product_t>(tags[i]);
    auto h2 = currentEvent_->getHandle(tokens[i]);
    BOOST_TEST(static_cast<bool>(h1) == static_cast<bool>(h2));
  }
}

BOOST_AUTO_TEST_CASE

(

getByInstanceName

)

Definition at line 466 of file Event_t.cc.

{
  using handle_t = Handle<product_t>;
  using handle_vec = std::vector<handle_t>;

  addSourceProduct(product_with_value(1), "int1_tag", "int1");
  addSourceProduct(product_with_value(2), "int2_tag", "int2");
  addSourceProduct(product_with_value(3), "int3_tag");
  addSourceProduct(product_with_value(4), "nolabel_tag");

  Selector const sel{ProductInstanceNameSelector{"int2"} &&
                     ModuleLabelSelector{"modMulti"}};
  auto h = currentEvent_->getHandle<product_t>(sel);
  BOOST_TEST_REQUIRE(h);
  BOOST_TEST(h->value == 2);

  Selector const sel2{ProductInstanceNameSelector{"int2"} ||
                      ProductInstanceNameSelector{"int1"}};
  auto handles = currentEvent_->getMany<product_t>(sel2);
  BOOST_TEST(handles.size() == std::size_t{2});

  std::string const instance;
  Selector sel1{ProductInstanceNameSelector{instance}};
  sel1 = Selector{sel1 && ModuleLabelSelector{"modMulti"}};

  BOOST_TEST_REQUIRE(currentEvent_->get(sel1, h));
  BOOST_TEST(h->value == 3);
  handles.clear();

  // There should be five registered products with the 'modMulti'
  // module label.
  auto tags = currentEvent_->getInputTags<product_t>(modMultiSelector);
  BOOST_TEST(tags.size() == 5u);
  // Now remove the unavailable products
  auto new_end =
    std::remove_if(begin(tags), end(tags), [this](auto const& tag) {
      return !currentEvent_->getHandle<product_t>(tag);
    });
  tags.erase(new_end, end(tags));

  // Only three of the registered products are available.
  handles = currentEvent_->getMany<product_t>(modMultiSelector);
  BOOST_TEST(handles.size() == 3u);

  // Make sure the resolved products agree with those specified in the
  // 'tags' variable above.  The products are resolved in the same
  // order as the input-tag list.
  for (std::size_t i{}; i < 3u; ++i) {
    BOOST_TEST(handles[i].provenance()->inputTag() == tags[i]);
  }

  handles = currentEvent_->getMany<product_t>(ModuleLabelSelector{"nomatch"});
  BOOST_TEST_REQUIRE(handles.empty());

  auto const nomatches = currentEvent_->getMany<int>(modMultiSelector);
  BOOST_TEST_REQUIRE(nomatches.empty());
}

BOOST_AUTO_TEST_CASE

(

getBySelector

)

Definition at line 524 of file Event_t.cc.

{
  using handle_t = Handle<product_t>;
  using handle_vec = std::vector<handle_t>;

  addSourceProduct(product_with_value(1), "int1_tag", "int1");
  addSourceProduct(product_with_value(2), "int2_tag", "int2");
  addSourceProduct(product_with_value(3), "int3_tag");
  addSourceProduct(product_with_value(4), "nolabel_tag");
  addSourceProduct(product_with_value(100), "int1_tag_late", "int1");

  currentEvent_->put(product_with_value(200), "int1");
  EDProducer::commitEvent(*principal_, *currentEvent_);

  Selector const sel{ProductInstanceNameSelector{"int2"} && modMultiSelector &&
                     ProcessNameSelector{"EARLY"}};
  handle_t h;
  BOOST_TEST_REQUIRE(currentEvent_->get(sel, h));
  BOOST_TEST(h->value == 2);

  Selector const sel1{ProductInstanceNameSelector{"nomatch"} &&
                      modMultiSelector && ProcessNameSelector{"EARLY"}};
  BOOST_TEST_REQUIRE(!currentEvent_->get(sel1, h));
  BOOST_TEST_REQUIRE(!h.isValid());
  BOOST_REQUIRE_THROW(*h, cet::exception);

  Selector const sel2{ProductInstanceNameSelector{"int2"} &&
                      ModuleLabelSelector{"nomatch"} &&
                      ProcessNameSelector{"EARLY"}};
  BOOST_TEST_REQUIRE(!currentEvent_->get(sel2, h));
  BOOST_TEST_REQUIRE(!h.isValid());
  BOOST_REQUIRE_THROW(*h, cet::exception);

  Selector const sel3{ProductInstanceNameSelector{"int2"} && modMultiSelector &&
                      ProcessNameSelector{"nomatch"}};
  BOOST_TEST_REQUIRE(!currentEvent_->get(sel3, h));
  BOOST_TEST_REQUIRE(!h.isValid());
  BOOST_REQUIRE_THROW(*h, cet::exception);

  Selector const sel4{modMultiSelector && ProcessNameSelector{"EARLY"}};
  // multiple selections throw
  BOOST_REQUIRE_THROW(currentEvent_->get(sel4, h), cet::exception);

  Selector const sel5{modMultiSelector && ProcessNameSelector{"LATE"}};
  BOOST_TEST_REQUIRE(currentEvent_->get(sel5, h));
  BOOST_TEST(h->value == 100);

  Selector const sel6{modMultiSelector && ProcessNameSelector{"CURRENT"}};
  BOOST_TEST_REQUIRE(currentEvent_->get(sel6, h));
  BOOST_TEST(h->value == 200);

  Selector const sel7{modMultiSelector};
  BOOST_TEST_REQUIRE(currentEvent_->get(sel7, h));
  BOOST_TEST(h->value == 200);

  auto handles = currentEvent_->getMany<product_t>(modMultiSelector);
  BOOST_TEST(size(handles) == 5u);
  int sum = 0;
  for (int k = 0; k < 5; ++k) {
    sum += handles[k]->value;
  }
  BOOST_TEST(sum == 306);
}

BOOST_AUTO_TEST_CASE

(

getByLabel

)

Definition at line 588 of file Event_t.cc.

{
  using handle_t = Handle<product_t>;
  using handle_vec = std::vector<handle_t>;

  addSourceProduct(product_with_value(1), "int1_tag", "int1");
  addSourceProduct(product_with_value(2), "int2_tag", "int2");
  addSourceProduct(product_with_value(3), "int3_tag");
  addSourceProduct(product_with_value(4), "nolabel_tag");
  addSourceProduct(product_with_value(100), "int1_tag_late", "int1");

  currentEvent_->put(product_with_value(200), "int1");

  EDProducer::commitEvent(*principal_, *currentEvent_);

  handle_t h;
  BOOST_TEST_REQUIRE(currentEvent_->getByLabel("modMulti", h));
  BOOST_TEST(h->value == 3);
  BOOST_TEST_REQUIRE(currentEvent_->getByLabel("modMulti", "int1", h));
  BOOST_TEST(h->value == 200);
  BOOST_TEST_REQUIRE(
    currentEvent_->getByLabel("modMulti", "int1", "CURRENT", h));
  BOOST_TEST(h->value == 200);
  BOOST_TEST_REQUIRE(
    currentEvent_->getByLabel("modMulti", "int1", "current_process", h));
  BOOST_TEST(h->value == 200);
  BOOST_TEST(!currentEvent_->getByLabel("modMulti", "nomatch", h));
  BOOST_TEST(!h.isValid());
  BOOST_CHECK_THROW(*h, cet::exception);

  InputTag const inputTag{"modMulti", "int1"};
  BOOST_TEST_REQUIRE(currentEvent_->getByLabel(inputTag, h));
  BOOST_TEST(h->value == 200);

  GroupQueryResult bh{principal_->getByLabel(currentModuleContext_,
                                             WrappedTypeID::make<product_t>(),
                                             "modMulti",
                                             "int1",
                                             ProcessTag{"LATE", "CURRENT"})};
  h = handle_t{bh};
  BOOST_TEST(h->value == 100);

  GroupQueryResult bh2{
    principal_->getByLabel(currentModuleContext_,
                           WrappedTypeID::make<product_t>(),
                           "modMulti",
                           "int1",
                           ProcessTag{"nomatch", "CURRENT"})};
  BOOST_TEST(!bh2.succeeded());
}

BOOST_AUTO_TEST_CASE

(

getByLabelSpecialProcessNames

)

Definition at line 639 of file Event_t.cc.

{
  addSourceProduct(product_with_value(2), "int2_tag", "int2");
  currentEvent_->put(product_with_value(200), "int1");

  // Try to retrieve something that does not exist in the current process.
  InputTag const badEarlyTag{"modMulti", "int2", "current_process"};
  BOOST_REQUIRE_THROW(currentEvent_->getValidHandle<product_t>(badEarlyTag),
                      cet::exception);

  // Verify that it can be read using the 'input_source' process name
  Handle<product_t> h;
  InputTag const goodEarlyTag{"modMulti", "int2", "input_source"};
  BOOST_TEST_REQUIRE(currentEvent_->getByLabel(goodEarlyTag, h));
  BOOST_TEST(h->value == 2);

  // Verify that "int1" cannot be looked up using the "input_source"
  // process name.
  InputTag const badCurrentTag{"modMulti", "int1", "input_source"};
  BOOST_CHECK_THROW(currentEvent_->getValidHandle<product_t>(badCurrentTag),
                    cet::exception);
}

BOOST_AUTO_TEST_CASE

(

getManyByType

)

Definition at line 662 of file Event_t.cc.

{
  addSourceProduct(product_with_value(1), "int1_tag", "int1");
  addSourceProduct(product_with_value(2), "int2_tag", "int2");
  addSourceProduct(product_with_value(3), "int3_tag");
  addSourceProduct(product_with_value(4), "nolabel_tag");

  addSourceProduct(product_with_value(100), "int1_tag_late", "int1");

  currentEvent_->put(product_with_value(200), "int1");
  EDProducer::commitEvent(*principal_, *currentEvent_);

  // Verify that the returned tags match thos provided through the
  // handles below.
  auto const tags = currentEvent_->getInputTags<product_t>();
  BOOST_TEST(tags.size() == 6u);

  auto const handles = currentEvent_->getMany<product_t>();
  BOOST_TEST(handles.size() == 6u);
  int sum = 0;
  for (int k = 0; k < 6; ++k) {
    auto const& h = handles[k];
    BOOST_TEST(tags[k] == h.provenance()->productDescription().inputTag());
    sum += h->value;
  }
  BOOST_TEST(sum == 310);
}

BOOST_AUTO_TEST_CASE

(

printHistory

)

Definition at line 690 of file Event_t.cc.

{
  auto const& history = currentEvent_->processHistory();
  std::ofstream out{"history.log"};

  cet::copy_all(
    history,
    std::ostream_iterator<ProcessHistory::const_iterator::value_type>(out,
                                                                      "\n"));
}