PluginLoader.cc File Reference

#include <boost/test/included/unit_test.hpp>
#include <boost/exception/all.hpp>
#include <boost/property_tree/info_parser.hpp>
#include <filesystem>
#include "Flow.h"
#include "GenericPlugin.h"
#include "Jet.h"
#include "MetaInfo.h"
#include "PluginLoader.h"
#include "exceptions.h"

Include dependency graph for PluginLoader.cc:

Classes
struct	AnotherPlugin

Macros
#define	BOOST_TEST_MODULE   PluginLoader

Functions
	BOOST_AUTO_TEST_CASE (basic_call)
	BOOST_AUTO_TEST_CASE (basic_exceptions)
	BOOST_AUTO_TEST_CASE (move_constructor)

Macro Definition Documentation

BOOST_TEST_MODULE

#define BOOST_TEST_MODULE   PluginLoader

Function Documentation

BOOST_AUTO_TEST_CASE() [1/3]

BOOST_AUTO_TEST_CASE

(

basic_call

)

    {
        fs::path file1 = "plugin_test_input.root",
                 file2 = "plugin_test_output.root";
 
        BOOST_TEST_MESSAGE( "Creating a tree" );
        {
            DT::Flow flow(DT::verbose);
            auto tOut = flow.GetOutputTree(file1);
            pt::ptree config;
            pt::read_info("example.info", config);
            DT::MetaInfo metainfo(tOut, config);
            BOOST_TEST( metainfo.Get<bool>("flags", "isMC") == true );
 
            auto recJets = flow.GetBranchWriteOnly<vector<DP::RecJet>>("recJets");
            DP::RecJet recJet;
            recJet.p4.SetPt(1.f);
            recJets->emplace_back(recJet);
 
            auto genJets = flow.GetBranchWriteOnly<vector<DP::GenJet>>("genJets");
            DP::GenJet genJet;
            genJet.p4.SetPt(2.f);
            genJets->emplace_back(genJet);
 
            tOut->Fill();
        }
 
        BOOST_TEST_MESSAGE( "Running the plugin on the tree" );
        {
            fs::path plugin_file = "../plugins/libFlattener." DLL_EXT;
            vector plugin_files(2, plugin_file);
 
            DT::Flow flow(DT::verbose, {file1});
            auto tIn = flow.GetInputTree();
            auto tOut = flow.GetOutputTree(file2);
            auto plugins = flow.GetPlugins<DT::GenericPlugin>(plugin_files);
 
            DT::MetaInfo metainfo(tOut, pt::ptree{});
            BOOST_TEST( metainfo.Get<bool>("flags", "isMC") == true );
 
            for (DT::GenericPlugin * plugin: plugins)
                plugin->Load(flow, metainfo);
 
            tIn->GetEntry(0);
            for (auto& plugin: plugins)
                plugin->ExecuteAtBegin();
            for (auto& plugin: plugins | views::reverse)
                plugin->ExecuteAtEnd();
 
            tOut->Fill();
        }
 
        BOOST_TEST_MESSAGE( "Checking the result from the plugin" );
        {
            DT::Flow flow(DT::verbose, {file2});
            auto tIn = flow.GetInputTree();
            tIn->Scan("recJets.CorrPt():Jet_pt");
            auto recJets = flow.GetBranchReadOnly<vector<DP::RecJet>>("recJets");
            auto Jet_pt = flow.GetBranchReadOnly<vector<float>>("Jet_pt");
            tIn->GetEntry(0);
            BOOST_TEST( 2*recJets->size() == Jet_pt->size() );
            BOOST_TEST( recJets->front().CorrPt() == Jet_pt->front() );
            BOOST_TEST( Jet_pt->at(0) == Jet_pt->at(1) );
        }
 
        BOOST_TEST_MESSAGE( "Testing forbidden modes" );
        {
            DT::Flow flow(DT::verbose, {file2});
            auto tIn [[ maybe_unused ]] = flow.GetInputTree();
            auto tOut = flow.GetOutputTree("/dev/null");
            DT::MetaInfo metainfo(tOut, pt::ptree{});
            BOOST_TEST( metainfo.Get<bool>("flags", "isMC") == true );
 
            BOOST_TEST_MESSAGE( "Testing an option forbidden by the plugin" );
            auto plugins = flow.GetPlugins<DT::IPlugin>(vector<fs::path>{"../plugins/libFlattener." DLL_EXT});
            BOOST_REQUIRE_THROW( (*ranges::begin(plugins))->Load(flow, metainfo, DT::syst), DE::PluginException );
            BOOST_REQUIRE_NO_THROW( (*ranges::begin(plugins))->Load(flow, metainfo, DT::verbose) );
        }
 
        BOOST_TEST_MESSAGE( "Testing veto" );
        {
            DT::Flow flow(DT::verbose, {file2});
            auto tIn [[ maybe_unused ]] = flow.GetInputTree();
            auto tOut = flow.GetOutputTree("/dev/null");
            DT::MetaInfo metainfo(tOut, pt::ptree{});
            BOOST_TEST( metainfo.Get<bool>("flags", "isMC") == true );
            auto plugins = flow.GetPlugins<DT::IPlugin>(vector<fs::path>{"libVetoPlugin." DLL_EXT});
 
            BOOST_TEST_MESSAGE( "Trying to veto DT::verbose" );
            auto plugin = ranges::begin(plugins);
            BOOST_REQUIRE_THROW( (*plugin)->Load(flow, metainfo, DT::verbose), DE::PluginException );
 
            BOOST_TEST_MESSAGE( "Trying default mode" );
            ++plugin;
            BOOST_REQUIRE_NO_THROW( (*plugin)->Load(flow, metainfo, DT::verbose) );
        }
    }

BOOST_AUTO_TEST_CASE() [2/3]

BOOST_AUTO_TEST_CASE

(

basic_exceptions

)

    {
        BOOST_TEST_MESSAGE( "Testing inexisting plugin" );
        BOOST_REQUIRE_THROW( DT::PluginLoader loader("/this/plugin/does/not/exist." DLL_EXT), DE::PluginException );
 
        BOOST_TEST_MESSAGE( "Testing fake plugin (creating empty file on the fly)" );
        const fs::path fake = "fake_plugin." DLL_EXT;
        fs::remove(fake);
        ofstream(fake.c_str());
        BOOST_REQUIRE_THROW( DT::PluginLoader loader(fake), DE::PluginException );
 
        BOOST_TEST_MESSAGE( "Testing inexisting plugin function" );
        BOOST_REQUIRE_THROW( DT::PluginLoader loader("libHist.so"), DE::PluginException );
 
        BOOST_TEST_MESSAGE( "Testing CreatePlugin when returning nullptr" );
        BOOST_REQUIRE_THROW( DT::PluginLoader loader("libFakePlugin." DLL_EXT), DE::PluginException );
 
        BOOST_TEST_MESSAGE( "Testing CreatePlugin when throwing an exception" );
        BOOST_REQUIRE_THROW( DT::PluginLoader loader("libBadPlugin." DLL_EXT), DE::PluginException );
 
        BOOST_TEST_MESSAGE( "Testing Get() with wrong plugin type" );
        DT::PluginLoader loader("../plugins/libFlattener." DLL_EXT);
        auto plugins = loader.Get<AnotherPlugin>();
        BOOST_REQUIRE_THROW( *ranges::begin(plugins), logic_error );
    }

BOOST_AUTO_TEST_CASE() [3/3]

BOOST_AUTO_TEST_CASE

(

move_constructor

)

    {
        BOOST_TEST_MESSAGE( "Loading a plugin" );
        DT::PluginLoader loader("../plugins/libFlattener." DLL_EXT, DT::verbose);
 
        BOOST_TEST_MESSAGE( "Moving a plugin" );
        DT::PluginLoader loader2(std::move(loader));
    }