ClosedRangeSetHandler_t.cc File Reference

#include "boost/test/unit_test.hpp"
#include "art/Framework/Principal/ClosedRangeSetHandler.h"
#include "art/test/Framework/Principal/SimpleEvent.h"
#include "canvas/Persistency/Common/detail/aggregate.h"
#include "canvas/Persistency/Provenance/RangeSet.h"
#include <vector>

Go to the source code of this file.

Macros
#define	BOOST_TEST_MODULE   (ClosedRangeSetHandler_t)

Functions
	BOOST_AUTO_TEST_CASE (EmptyRunAndSubRuns)
	BOOST_AUTO_TEST_CASE (SplitOnNonLastSubRunEvent)
	BOOST_AUTO_TEST_CASE (SplitOnLastSubRunEvent)

Macro Definition Documentation

#define BOOST_TEST_MODULE   (ClosedRangeSetHandler_t)

Definition at line 1 of file ClosedRangeSetHandler_t.cc.

Function Documentation

BOOST_AUTO_TEST_CASE

(

EmptyRunAndSubRuns

)

Definition at line 102 of file ClosedRangeSetHandler_t.cc.

{
  // In this case, no events were seen in any of the runs/subruns.  So
  // flush the ranges.
  for (std::size_t i{0}; i != 3; ++i) {
    srHandlers[i]->flushRanges();
    auto const& rs = RangeSet{1, eventRanges(i)};
    BOOST_TEST(srHandlers[i]->seenRanges() == rs);
  }

  rHandler->flushRanges();
  std::vector<EventRange> runRef;
  for (std::size_t i{0}; i != 3; ++i) {
    concatenate(runRef, eventRanges(i));
  }
  RangeSet const runRSRef{1, runRef};
  BOOST_TEST(rHandler->seenRanges() == runRSRef);
}

BOOST_AUTO_TEST_CASE

(

SplitOnNonLastSubRunEvent

)

Definition at line 121 of file ClosedRangeSetHandler_t.cc.

{
  // For this test, we're in the middle of processing SubRun 1 at
  // event 5, when we decide to switch to a new input file.  In this
  // case, 5 IS NOT the last processed event in the SubRun.

  std::vector<SimpleEvent> events;
  events.emplace_back(EventID{1, 1, 3}, false);
  events.emplace_back(EventID{1, 1, 4}, false);
  events.emplace_back(EventID{1, 1, 5}, false);

  auto const& srHandler = srHandlers[1];
  // Process events
  for (auto const& e : events) {
    srHandler->update(e.id, e.lastInSubRun);
    rHandler->update(e.id, e.lastInSubRun);
  }

  // Simulate file switch
  // 1. Maybe split range
  srHandler->maybeSplitRange();
  rHandler->maybeSplitRange();

  {
    std::vector<EventRange> subRunRef;
    subRunRef.emplace_back(1, 1, 6);
    RangeSet const subRunRSRef{1, subRunRef};
    BOOST_TEST(srHandler->seenRanges() == subRunRSRef);
  }

  {
    std::vector<EventRange> runRef;
    runRef.emplace_back(0, 5, 11);
    runRef.emplace_back(1, 1, 6);
    RangeSet const runRSRef{1, runRef};
    BOOST_TEST(rHandler->seenRanges() == runRSRef);
  }

  // 2. Rebase ranges
  srHandler->rebase();
  rHandler->rebase();

  // Process last event
  SimpleEvent const lastEvent{EventID{1, 1, 10}, true};
  srHandler->update(lastEvent.id, lastEvent.lastInSubRun);
  rHandler->update(lastEvent.id, lastEvent.lastInSubRun);

  // Simulate end of subrun and run
  srHandler->flushRanges();
  rHandler->flushRanges();
  {
    std::vector<EventRange> subRunRef;
    subRunRef.emplace_back(1, 6, 7);
    subRunRef.emplace_back(1, 9, 15);
    RangeSet const subRunRSRef{1, subRunRef};
    BOOST_TEST(srHandler->seenRanges() == subRunRSRef);
  }
  {
    std::vector<EventRange> runRef;
    runRef.emplace_back(1, 6, 7);
    runRef.emplace_back(1, 9, 15);
    runRef.emplace_back(2, 3, 15);
    RangeSet const runRSRef{1, runRef};
    BOOST_TEST(rHandler->seenRanges() == runRSRef);
  }
}

BOOST_AUTO_TEST_CASE

(

SplitOnLastSubRunEvent

)

Definition at line 188 of file ClosedRangeSetHandler_t.cc.

{
  // For this test, we're in the middle of processing SubRun 1 at
  // event 5, when we decide to switch to a new input file.  In this
  // case, 5 IS the last processed event in the SubRun.

  std::vector<SimpleEvent> events;
  events.emplace_back(EventID{1, 1, 3}, false);
  events.emplace_back(EventID{1, 1, 4}, false);
  events.emplace_back(EventID{1, 1, 5}, true);

  auto const& srHandler = srHandlers[1];
  // Process events
  for (auto const& e : events) {
    srHandler->update(e.id, e.lastInSubRun);
    rHandler->update(e.id, e.lastInSubRun);
  }

  // Simulate file switch
  srHandler->maybeSplitRange();
  rHandler->maybeSplitRange();
  {
    RangeSet const subRunRSRef{1, eventRanges(1)};
    BOOST_TEST(srHandler->seenRanges() == subRunRSRef);
  }
  {
    std::vector<EventRange> runRef;
    concatenate(runRef, eventRanges(0));
    concatenate(runRef, eventRanges(1));
    RangeSet const runRSRef{1, runRef};
    BOOST_TEST(rHandler->seenRanges() == runRSRef);
  }
  srHandler->rebase();
  rHandler->rebase();

  // Both RangeSets should now be empty (have not yet processed any
  // events from SubRun 2).
  RangeSet const emptyRS{1, std::vector<EventRange>{}};
  BOOST_TEST(srHandler->seenRanges() == emptyRS);
  BOOST_TEST(rHandler->seenRanges() == emptyRS);
}