FunctionalCoreTest.cxx

#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers.hpp>
 
#include "Framework/EventFile.h"
#include "Framework/EventProcessor.h"
#include "Framework/Process.h"
#include "Framework/RunHeader.h"
#include "Hcal/Event/HcalHit.h"
#include "Hcal/Event/HcalVetoResult.h"
#include "Recon/Event/CalorimeterHit.h"
#include "TFile.h"        //to open and check root files
#include "TTreeReader.h"  //to check output event files
 
using Catch::Approx;
 
namespace framework {
namespace test {
 
class TestProducer : public Producer {
  int events_;
 
  bool create_run_header_;
 
  int throw_after_;
 
 public:
  TestProducer(const std::string& name, Process& p) : Producer(name, p) {}
  ~TestProducer() {}
 
  void configure(framework::config::Parameters& p) final override {
    create_run_header_ = p.get<bool>("create_run_header");
    throw_after_ = p.get<int>("throw_after", -1);
  }
 
  void beforeNewRun(ldmx::RunHeader& header) final override {
    if (not create_run_header_) return;
    header.setIntParameter("Should Be Run Number", header.getRunNumber());
    return;
  }
 
  void produce(framework::Event& event) final override {
    int i_event = event.getEventNumber();
 
    REQUIRE(i_event > 0);
 
    // stand-in for a kill mid-write
    if (throw_after_ > 0 and i_event > throw_after_) {
      EXCEPTION_RAISE("TestKill", "Pretending to be killed mid-run.");
    }
 
    std::vector<ldmx::CalorimeterHit> calo_hits;
    for (int i = 0; i < i_event; i++) {
      calo_hits.emplace_back();
      calo_hits.back().setID(i_event * 10 + i);
    }
 
    REQUIRE_NOTHROW(event.add("TestCollection", calo_hits));
 
    ldmx::HcalHit max_pe_hit;
    max_pe_hit.setID(i_event);
 
    ldmx::HcalVetoResult res;
    res.setMaxPEHit(max_pe_hit);
    res.setVetoResult(i_event % 2 == 0);
 
    REQUIRE_NOTHROW(event.add("TestObject", res));
 
    events_ = i_event;
 
    std::vector<int> event_indices = {i_event, i_event};
    REQUIRE_NOTHROW(event.add("EventIndex", event_indices));
 
    float test_float = i_event * 0.1;
    REQUIRE_NOTHROW(event.add("EventTenth", test_float));
 
    if (res.passesVeto()) setStorageHint(StorageControl::Hint::MustKeep);
 
    return;
  }
};  // TestProducer
 
class TestAnalyzer : public Analyzer {
 private:
  std::string test_collection_passname_;
  std::string test_object_passname_;
  std::string veto_test_object_passname_;
  std::string tenth_event_passname_;
  std::string event_index_passname_;
 
 public:
  TestAnalyzer(const std::string& name, Process& p) : Analyzer(name, p) {}
  ~TestAnalyzer() {}
 
  void configure(framework::config::Parameters& ps) override {
    test_collection_passname_ =
        ps.get<std::string>("test_collection_passname", "");
    test_object_passname_ = ps.get<std::string>("test_object_passname", "");
    veto_test_object_passname_ =
        ps.get<std::string>("veto_test_object_passname", "");
    tenth_event_passname_ = ps.get<std::string>("tenth_event_passname", "");
    event_index_passname_ = ps.get<std::string>("event_index_passname", "");
  }
 
  void onProcessStart() final override {
    REQUIRE_NOTHROW(getHistoDirectory());
    test_hist_ = new TH1F("test_hist_", "Test Histogram", 101, -50, 50);
    test_hist_->SetCanExtend(TH1::kAllAxes);
  }
 
  void analyze(const framework::Event& event) final override {
    int i_event = event.getEventNumber();
 
    REQUIRE(i_event > 0);
 
    const std::vector<ldmx::CalorimeterHit>& calo_hits =
        event.getCollection<ldmx::CalorimeterHit>("TestCollection",
                                                  test_collection_passname_);
 
    CHECK(calo_hits.size() == i_event);
    for (unsigned int i = 0; i < calo_hits.size(); i++) {
      CHECK(calo_hits.at(i).getID() == i_event * 10 + i);
      test_hist_->Fill(calo_hits.at(i).getID());
    }
 
    const ldmx::HcalVetoResult& veto_res =
        event.getObject<ldmx::HcalVetoResult>("TestObject",
                                              veto_test_object_passname_);
 
    auto max_pe_hit{veto_res.getMaxPEHit()};
 
    CHECK(max_pe_hit.getID() == i_event);
    CHECK(veto_res.passesVeto() == (i_event % 2 == 0));
 
    const float& tenth_event =
        event.getObject<float>("EventTenth", tenth_event_passname_);
    CHECK(tenth_event == Approx(i_event * 0.1));
 
    const std::vector<int>& i_event_from_bus =
        event.getCollection<int>("EventIndex", event_index_passname_);
 
    CHECK(i_event_from_bus.size() == 2);
    CHECK(i_event_from_bus.at(0) == i_event);
    CHECK(i_event_from_bus.at(1) == i_event);
 
    return;
  }
 
 private:
  TH1F* test_hist_;
};  // TestAnalyzer
 
class IsGoodhistogramFile : public Catch::Matchers::MatcherBase<std::string> {
 private:
  int correct_get_entries_;
 
 public:
  IsGoodhistogramFile(int const& n) : correct_get_entries_(n) {}
 
  bool match(const std::string& filename) const override {
    // Open file
    TFile* f = TFile::Open(filename.c_str());
    if (!f) return false;
    TDirectory* d = (TDirectory*)f->Get("TestAnalyzer");
    if (!d) return false;
    TH1F* h = (TH1F*)d->Get("test_hist_");
    if (!h) return false;
 
    return (h->GetEntries() == correct_get_entries_);
  }
 
  virtual std::string describe() const override {
    std::ostringstream ss;
    ss << "has the histogram 'TestAnalyzer/test_hist_' with the number of "
          "entries "
       << correct_get_entries_;
    return ss.str();
  }
};  // isGoodhistogram_file
 
class IsGoodEventFile : public Catch::Matchers::MatcherBase<std::string> {
 private:
  std::string pass_;
 
  int entries_;
 
  int runs_;
 
  bool exist_collection_;
 
  bool exist_object_;
 
 public:
  IsGoodEventFile(const std::string& pass, const int& entries, const int& runs,
                  bool existColl = true, bool existObj = true)
      : pass_(pass),
        entries_(entries),
        runs_(runs),
        exist_collection_(existColl),
        exist_object_(existObj) {}
 
  bool match(const std::string& filename) const override {
    TFile* f = TFile::Open(filename.c_str());
    if (!f) return false;
 
    TTreeReader events("LDMX_Events", f);
 
    if (events.GetEntries(true) != entries_) {
      f->Close();
      return false;
    }
 
    // Event tree should _always_ have the ldmx::EventHeader
    TTreeReaderValue<ldmx::EventHeader> header(events, "EventHeader");
 
    if (exist_collection_) {
      // make sure collection matches pattern
      TTreeReaderValue<std::vector<ldmx::CalorimeterHit>> collection(
          events, ("TestCollection_" + pass_).c_str());
      while (events.Next()) {
        if (collection->size() != header->getEventNumber()) {
          f->Close();
          return false;
        }
        for (unsigned int i = 0; i < collection->size(); i++)
          if (collection->at(i).getID() != header->getEventNumber() * 10 + i) {
            f->Close();
            return false;
          }
      }
      // restart in case checking object as well
      events.Restart();
    } else {
      // check to make sure collection is NOT there
      auto t{(TTree*)f->Get("LDMX_Events")};
      if (t and t->GetBranch(("TestCollection_" + pass_).c_str())) {
        f->Close();
        return false;
      }
    }
 
    if (exist_object_) {
      // make sure object matches pattern
      TTreeReaderValue<ldmx::HcalVetoResult> object(
          events, ("TestObject_" + pass_).c_str());
      while (events.Next()) {
        if (object->getMaxPEHit().getID() != header->getEventNumber()) {
          f->Close();
          return false;
        }
      }
    } else {
      // check to make sure object is NOT there
      auto t{(TTree*)f->Get("LDMX_Events")};
      if (t and t->GetBranch(("TestObject_" + pass_).c_str())) {
        f->Close();
        return false;
      }
    }
 
    TTreeReader runs("LDMX_Run", f);
 
    if (runs.GetEntries(true) != runs_) {
      f->Close();
      return false;
    }
 
    TTreeReaderValue<ldmx::RunHeader> run_header(runs, "RunHeader");
 
    while (runs.Next()) {
      if (run_header->getRunNumber() !=
          run_header->getIntParameter("Should Be Run Number")) {
        f->Close();
        return false;
      }
    }
 
    f->Close();
 
    return true;
  }
 
  virtual std::string describe() const override {
    std::ostringstream ss;
    ss << "can be opened and has the correct number of entries in the event "
          "tree and the run tree.";
 
    ss << " TestCollection_" << pass_ << " was verified to ";
    if (exist_collection_)
      ss << " be the correct pattern.";
    else
      ss << " not be in the file.";
 
    ss << " TestObject_" << pass_ << " was verified to ";
    if (exist_object_)
      ss << " be the correct pattern.";
    else
      ss << " not be in the file.";
 
    return ss.str();
  }
 
};  // isGoodEventFile
 
static bool removeFile(const std::string& filepath) {
  return remove(filepath.c_str()) == 0;
}
 
static void stripRunHeader(const std::string& source,
                           const std::string& destination) {
  TFile src(source.c_str());
  REQUIRE(not src.IsZombie());
  auto events{static_cast<TTree*>(src.Get("LDMX_Events"))};
  REQUIRE(events != nullptr);
 
  TFile dst(destination.c_str(), "RECREATE");
  REQUIRE(dst.IsOpen());
  dst.cd();
  auto copy{events->CloneTree(-1, "fast")};
  REQUIRE(copy != nullptr);
  copy->Write();
  dst.Close();
  src.Close();
 
  // the point of the exercise
  TFile check(destination.c_str());
  REQUIRE(check.Get("LDMX_Run") == nullptr);
  check.Close();
}
 
static bool isCompleted(const std::string& path) {
  TFile f(path.c_str());
  REQUIRE(not f.IsZombie());
  REQUIRE(f.Get("LDMX_Run") != nullptr);
  TTreeReader runs("LDMX_Run", &f);
  TTreeReaderValue<ldmx::RunHeader> run_header(runs, "RunHeader");
  REQUIRE(runs.Next());
  bool completed{run_header->isCompleted()};
  f.Close();
  return completed;
}
 
static bool runProcess(const framework::config::Parameters& parameters) {
  ProcessHandle p;
  try {
    p = std::make_unique<Process>(parameters);
  } catch (framework::exception::Exception& e) {
    std::cerr << "Config Error [" << e.name() << "] : " << e.message()
              << std::endl;
    std::cerr << "  at " << e.module() << ":" << e.line() << " in "
              << e.function() << std::endl;
    return false;
  }
  p->run();
  return true;
}
 
}  // namespace test
}  // namespace framework
 
DECLARE_PRODUCER(framework::test::TestProducer)
DECLARE_ANALYZER(framework::test::TestAnalyzer)
 
 
TEST_CASE("Core Framework Functionality", "[Framework][functionality]") {
  // these parameters aren't tested/changed, so we set them out here
  framework::config::Parameters process;
  process.add("compression_setting", 9);
  process.add("max_tries_per_event", 1);
  process.add("log_frequency", -1);
  process.add("term_log_level", 4);
  process.add("file_log_level", 4);
  process.add<std::string>("log_file_name", "");
  process.add<std::string>("tree_name", "LDMX_Events");
 
  framework::config::Parameters producer_parameters;
  producer_parameters.add<std::string>("class_name",
                                       "framework::test::TestProducer");
  producer_parameters.add<std::string>("instance_name", "TestProducer");
 
  framework::config::Parameters analyzer_parameters;
  analyzer_parameters.add<std::string>("class_name",
                                       "framework::test::TestAnalyzer");
  analyzer_parameters.add<std::string>("instance_name", "TestAnalyzer");
 
  // declare used and re-used types, not used in all branches
  std::vector<framework::config::Parameters> sequence;
  std::vector<std::string> input_files, output_files;
 
  SECTION("Production Mode") {
    // no input files, only output files
 
    output_files = {"test_productionmode_events.root"};
    process.add<std::string>("pass_name", "test");
    process.add("output_files", output_files);
    process.add("max_events", 3);
    process.add("run", 3);
 
    producer_parameters.add("create_run_header", true);
 
    sequence = {producer_parameters};
 
    SECTION("only producers") {
      process.add("sequence", sequence);
      process.add<std::string>("histogram_file", "");
      SECTION("no drop/keep rules") {
        // Process owns and deletes the processors
        REQUIRE(framework::test::runProcess(process));
        CHECK_THAT(output_files.at(0),
                   framework::test::IsGoodEventFile("test", 3, 1));
      }
 
      SECTION("drop TestCollection") {
        std::vector<std::string> keep = {"drop .*Collection.*"};
        process.add("keep", keep);
        REQUIRE(framework::test::runProcess(process));
        CHECK_THAT(output_files.at(0),
                   framework::test::IsGoodEventFile("test", 3, 1, false));
      }
 
      SECTION("skim for even indexed events") {
        process.add("skim_default_is_keep", false);
        std::vector<std::string> rules = {"TestProducer", ""};
        process.add("skim_rules", rules);
        REQUIRE(framework::test::runProcess(process));
        CHECK_THAT(output_files.at(0),
                   framework::test::IsGoodEventFile("test", 1, 1));
      }
    }
 
    SECTION("with Analyses") {
      std::string hist_file_path =
          "test_productionmode_withanalyses_hists.root";
 
      process.add("histogram_file", hist_file_path);
 
      sequence.push_back(analyzer_parameters);
      process.add("sequence", sequence);
 
      SECTION("no drop/keep rules") {
        REQUIRE(framework::test::runProcess(process));
        CHECK_THAT(output_files.at(0),
                   framework::test::IsGoodEventFile("test", 3, 1));
      }
 
      SECTION("drop TestCollection") {
        std::vector<std::string> keep = {"drop .*Collection.*"};
        process.add("keep", keep);
        REQUIRE(framework::test::runProcess(process));
        CHECK_THAT(output_files.at(0),
                   framework::test::IsGoodEventFile("test", 3, 1, false));
      }
 
      SECTION("skim for even indexed events") {
        process.add("skim_default_is_keep", false);
        std::vector<std::string> rules = {"TestProducer", ""};
        process.add("skim_rules", rules);
        REQUIRE(framework::test::runProcess(process));
        CHECK_THAT(output_files.at(0),
                   framework::test::IsGoodEventFile("test", 1, 1));
      }
 
      CHECK_THAT(hist_file_path,
                 framework::test::IsGoodhistogramFile(1 + 2 + 3));
      CHECK(framework::test::removeFile(hist_file_path));
    }
 
    CHECK(framework::test::removeFile(output_files.at(0)));
  }  // Production Mode
 
  SECTION("Need Input Files") {
    input_files = {"test_needinputfiles_2_events.root",
                   "test_needinputfiles_3_events.root",
                   "test_needinputfiles_4_events.root"};
 
    for (int run{2}; run < 5; run++) {
      auto make_inputs = process;
      make_inputs.add<std::string>("pass_name", "makeInputs");
      auto producer = producer_parameters;
      producer.add("create_run_header", true);
      make_inputs.add<std::vector<framework::config::Parameters>>("sequence",
                                                                  {producer});
      output_files = {input_files.at(run - 2)};
      make_inputs.add("output_files", output_files);
      make_inputs.add("max_events", run);
      make_inputs.add("run", run);
      REQUIRE(framework::test::runProcess(make_inputs));
      REQUIRE_THAT(input_files.at(run - 2),
                   framework::test::IsGoodEventFile("makeInputs", run, 1));
    }
    process.add<std::string>("pass_name", "test");
 
    SECTION("Analysis Mode") {
      // no output files, only histogram output
 
      sequence = {analyzer_parameters};
      process.add("sequence", sequence);
 
      std::string hist_file_path = "test_analysismode_hists.root";
      process.add("histogram_file", hist_file_path);
 
      SECTION("one input file") {
        std::vector<std::string> input_file = {input_files.at(0)};
        process.add("input_files", input_file);
        REQUIRE(framework::test::runProcess(process));
        CHECK_THAT(hist_file_path, framework::test::IsGoodhistogramFile(1 + 2));
        CHECK(framework::test::removeFile(hist_file_path));
      }
 
      SECTION("multiple input files") {
        process.add("input_files", input_files);
        REQUIRE(framework::test::runProcess(process));
        CHECK_THAT(hist_file_path, framework::test::IsGoodhistogramFile(
                                       1 + 2 + 1 + 2 + 3 + 1 + 2 + 3 + 4));
        CHECK(framework::test::removeFile(hist_file_path));
      }
 
    }  // Analysis Mode
 
    SECTION("Evolve Mode") {
      // one input file to one output file
      std::vector<std::string> input_file = {input_files.at(0)};
      process.add("input_files", input_file);
 
      std::string event_file_path = "test_evolvemode_events.root";
      output_files = {event_file_path};
      process.add("output_files", output_files);
 
      SECTION("drop TestCollection") {
        std::vector<std::string> keep = {"drop .*Collection.*"};
        process.add("keep", keep);
        REQUIRE(framework::test::runProcess(process));
        CHECK_THAT(event_file_path,
                   framework::test::IsGoodEventFile("makeInputs", 2, 1, false));
      }
    }
 
    SECTION("Merge Mode") {
      // many input files to one output file
 
      process.add("input_files", input_files);
 
      std::string event_file_path = "test_mergemode_events.root";
      output_files = {event_file_path};
      process.add("output_files", output_files);
 
      SECTION("with analyzers") {
        sequence = {analyzer_parameters};
 
        std::string hist_file_path = "test_mergemode_withanalyzers_hists.root";
 
        process.add("sequence", sequence);
        process.add("histogram_file", hist_file_path);
 
        SECTION("no drop/keep rules") {
          REQUIRE(framework::test::runProcess(process));
          CHECK_THAT(event_file_path, framework::test::IsGoodEventFile(
                                          "makeInputs", 2 + 3 + 4, 3));
        }
 
        SECTION("drop TestCollection") {
          std::vector<std::string> keep = {"drop .*Collection.*"};
          process.add("keep", keep);
          REQUIRE(framework::test::runProcess(process));
          CHECK_THAT(event_file_path, framework::test::IsGoodEventFile(
                                          "makeInputs", 2 + 3 + 4, 3, false));
        }
 
        CHECK_THAT(hist_file_path, framework::test::IsGoodhistogramFile(
                                       1 + 2 + 1 + 2 + 3 + 1 + 2 + 3 + 4));
        CHECK(framework::test::removeFile(hist_file_path));
      }
 
      SECTION("with producers") {
        producer_parameters.add("create_run_header", false);
        sequence = {producer_parameters};
 
        process.add("sequence", sequence);
 
        SECTION("not listening to storage hints") {
          REQUIRE(framework::test::runProcess(process));
          CHECK_THAT(event_file_path,
                     framework::test::IsGoodEventFile("test", 2 + 3 + 4, 3));
        }
 
        SECTION("skim for even indexed events") {
          process.add("skim_default_is_keep", false);
          std::vector<std::string> rules = {"TestProducer", ""};
          process.add("skim_rules", rules);
          REQUIRE(framework::test::runProcess(process));
          CHECK_THAT(event_file_path,
                     framework::test::IsGoodEventFile("test", 1 + 1 + 2, 3));
        }
      }
 
      CHECK(framework::test::removeFile(event_file_path));
 
    }  // Merge Mode
 
  }  // need input files
 
}  // process test
 
TEST_CASE("Missing Run Header", "[Framework][functionality]") {
  framework::config::Parameters process;
  process.add("compression_setting", 9);
  process.add("max_tries_per_event", 1);
  process.add("log_frequency", -1);
  process.add("term_log_level", 4);
  process.add("file_log_level", 4);
  process.add<std::string>("log_file_name", "");
  process.add<std::string>("tree_name", "LDMX_Events");
 
  framework::config::Parameters producer_parameters;
  producer_parameters.add<std::string>("class_name",
                                       "framework::test::TestProducer");
  producer_parameters.add<std::string>("instance_name", "TestProducer");
 
  framework::config::Parameters analyzer_parameters;
  analyzer_parameters.add<std::string>("class_name",
                                       "framework::test::TestAnalyzer");
  analyzer_parameters.add<std::string>("instance_name", "TestAnalyzer");
 
  const std::string healthy_file{"test_missingrh_healthy_events.root"};
  const std::string headerless_file{"test_missingrh_headerless_events.root"};
 
  // healthy file, then take its run header away
  {
    auto make_inputs = process;
    make_inputs.add<std::string>("pass_name", "makeInputs");
    auto producer = producer_parameters;
    producer.add("create_run_header", true);
    make_inputs.add<std::vector<framework::config::Parameters>>("sequence",
                                                                {producer});
    make_inputs.add("output_files", std::vector<std::string>{healthy_file});
    make_inputs.add<std::string>("histogram_file", "");
    make_inputs.add("max_events", 3);
    make_inputs.add("run", 3);
    REQUIRE(framework::test::runProcess(make_inputs));
    REQUIRE_THAT(healthy_file,
                 framework::test::IsGoodEventFile("makeInputs", 3, 1));
  }
  framework::test::stripRunHeader(healthy_file, headerless_file);
 
  process.add<std::string>("pass_name", "test");
  std::string hist_file_path = "test_missingrh_hists.root";
  process.add("histogram_file", hist_file_path);
  process.add<std::vector<framework::config::Parameters>>(
      "sequence", {analyzer_parameters});
  process.add("input_files", std::vector<std::string>{headerless_file});
 
  CHECK_THROWS_AS(framework::test::runProcess(process),
                  framework::exception::Exception);
 
  CHECK(framework::test::removeFile(hist_file_path));
  CHECK(framework::test::removeFile(headerless_file));
  CHECK(framework::test::removeFile(healthy_file));
}  // missing run header test
 
TEST_CASE("Output Completeness", "[Framework][functionality]") {
  framework::config::Parameters process;
  process.add("compression_setting", 9);
  process.add("max_tries_per_event", 1);
  process.add("log_frequency", -1);
  process.add("term_log_level", 4);
  process.add("file_log_level", 4);
  process.add<std::string>("log_file_name", "");
  process.add<std::string>("tree_name", "LDMX_Events");
  process.add<std::string>("pass_name", "test");
  process.add<std::string>("histogram_file", "");
  process.add("max_events", 5);
  process.add("run", 3);
 
  framework::config::Parameters producer_parameters;
  producer_parameters.add<std::string>("class_name",
                                       "framework::test::TestProducer");
  producer_parameters.add<std::string>("instance_name", "TestProducer");
  producer_parameters.add("create_run_header", true);
 
  const std::string output_file{"test_completeness_events.root"};
  process.add("output_files", std::vector<std::string>{output_file});
 
  SECTION("a clean close is marked completed") {
    process.add<std::vector<framework::config::Parameters>>(
        "sequence", {producer_parameters});
    REQUIRE(framework::test::runProcess(process));
    CHECK(framework::test::isCompleted(output_file));
    CHECK_THAT(output_file, framework::test::IsGoodEventFile("test", 5, 1));
  }
 
  SECTION("an interrupted run is not") {
    // die partway, as a preemption would
    producer_parameters.add("throw_after", 3);
    process.add<std::vector<framework::config::Parameters>>(
        "sequence", {producer_parameters});
    CHECK_THROWS_AS(framework::test::runProcess(process),
                    framework::exception::Exception);
    // present because it was written at open, not on close
    CHECK_FALSE(framework::test::isCompleted(output_file));
    // and it carries what the producer put in it
    CHECK_THAT(output_file, framework::test::IsGoodEventFile("test", 3, 1));
  }
 
  CHECK(framework::test::removeFile(output_file));
}  // output completeness test
 
TEST_CASE("Incomplete Input", "[Framework][functionality]") {
  framework::config::Parameters process;
  process.add("compression_setting", 9);
  process.add("max_tries_per_event", 1);
  process.add("log_frequency", -1);
  process.add("term_log_level", 4);
  process.add("file_log_level", 4);
  process.add<std::string>("log_file_name", "");
  process.add<std::string>("tree_name", "LDMX_Events");
 
  framework::config::Parameters producer_parameters;
  producer_parameters.add<std::string>("class_name",
                                       "framework::test::TestProducer");
  producer_parameters.add<std::string>("instance_name", "TestProducer");
  producer_parameters.add("create_run_header", true);
 
  framework::config::Parameters analyzer_parameters;
  analyzer_parameters.add<std::string>("class_name",
                                       "framework::test::TestAnalyzer");
  analyzer_parameters.add<std::string>("instance_name", "TestAnalyzer");
 
  const std::string complete_file{"test_incompletein_complete_events.root"};
  const std::string incomplete_file{"test_incompletein_incomplete_events.root"};
 
  // one file that closes cleanly and one that dies partway
  {
    auto make_inputs = process;
    make_inputs.add<std::string>("pass_name", "makeInputs");
    make_inputs.add<std::vector<framework::config::Parameters>>(
        "sequence", {producer_parameters});
    make_inputs.add("output_files", std::vector<std::string>{complete_file});
    make_inputs.add<std::string>("histogram_file", "");
    make_inputs.add("max_events", 3);
    make_inputs.add("run", 3);
    REQUIRE(framework::test::runProcess(make_inputs));
    REQUIRE(framework::test::isCompleted(complete_file));
  }
  {
    auto make_inputs = process;
    make_inputs.add<std::string>("pass_name", "makeInputs");
    auto producer = producer_parameters;
    producer.add("throw_after", 3);  // die partway, as a preemption would
    make_inputs.add<std::vector<framework::config::Parameters>>("sequence",
                                                                {producer});
    make_inputs.add("output_files", std::vector<std::string>{incomplete_file});
    make_inputs.add<std::string>("histogram_file", "");
    make_inputs.add("max_events", 5);
    make_inputs.add("run", 4);
    REQUIRE_THROWS_AS(framework::test::runProcess(make_inputs),
                      framework::exception::Exception);
    REQUIRE_FALSE(framework::test::isCompleted(incomplete_file));
  }
 
  process.add<std::string>("pass_name", "test");
  std::string hist_file_path = "test_incompletein_hists.root";
  process.add("histogram_file", hist_file_path);
  process.add<std::vector<framework::config::Parameters>>(
      "sequence", {analyzer_parameters});
 
  SECTION("an unfinished run is refused") {
    process.add("input_files", std::vector<std::string>{incomplete_file});
    CHECK_THROWS_AS(framework::test::runProcess(process),
                    framework::exception::Exception);
  }
 
  SECTION("an unfinished run is refused even alongside good files") {
    process.add("input_files",
                std::vector<std::string>{complete_file, incomplete_file});
    CHECK_THROWS_AS(framework::test::runProcess(process),
                    framework::exception::Exception);
  }
 
  SECTION("experts can ask for it anyway") {
    process.add("input_files", std::vector<std::string>{incomplete_file});
    process.add("allow_incomplete_input_files", true);
    CHECK(framework::test::runProcess(process));
    CHECK_THAT(hist_file_path, framework::test::IsGoodhistogramFile(1 + 2 + 3));
  }
 
  SECTION("a complete run is let through") {
    process.add("input_files", std::vector<std::string>{complete_file});
    CHECK(framework::test::runProcess(process));
    CHECK_THAT(hist_file_path, framework::test::IsGoodhistogramFile(1 + 2 + 3));
  }
 
  CHECK(framework::test::removeFile(hist_file_path));
  CHECK(framework::test::removeFile(incomplete_file));
  CHECK(framework::test::removeFile(complete_file));
}  // incomplete input test