MetaInfo.cc File Reference

#include <boost/test/included/unit_test.hpp>
#include <boost/exception/all.hpp>
#include "test.h"
#include "MetaInfo.h"
#include <TFile.h>
#include <TTree.h>
#include <memory>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/info_parser.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/xml_parser.hpp>

Include dependency graph for MetaInfo.cc:

Macros
#define	BOOST_TEST_MODULE   testMetaInfo

Functions
	BOOST_AUTO_TEST_CASE (flags_and_corrections)
	BOOST_AUTO_TEST_CASE (git)
	BOOST_AUTO_TEST_CASE (software_version)

Macro Definition Documentation

BOOST_TEST_MODULE

#define BOOST_TEST_MODULE   testMetaInfo

Function Documentation

BOOST_AUTO_TEST_CASE() [1/3]

BOOST_AUTO_TEST_CASE

(

flags_and_corrections

)

    {
        pt::ptree config;
        BOOST_REQUIRE_NO_THROW( pt::read_info(DARWIN "/test/example.info", config) );
 
        auto events = make_unique<TTree>("events", "events");
 
        MetaInfo metainfo1(events, config);
        BOOST_TEST( metainfo1.Get<bool>("flags", "isMC") == true );
        BOOST_TEST_MESSAGE( "Checking reproducibility" );
        BOOST_TEST_WARN( metainfo1.Get<bool>("git", "reproducible") == true );
        events->GetUserInfo()->ls();
 
        hash<UserInfo> HashM;
        MetaInfo metainfo2(events, config);
        BOOST_TEST( HashM(metainfo1) == HashM(metainfo2) );
 
        BOOST_TEST_MESSAGE( "Checking inconsistent preseeds" );
        config.put<int>("preseed", 42);
        BOOST_REQUIRE_NO_THROW( MetaInfo(events, config) );
 
        BOOST_TEST_MESSAGE( "Checking exception in case of inconsistent flags" );
        config.put<bool>("flags.isMC", false);
        config.put<bool>("flags.label", "aNewLabel");
        BOOST_REQUIRE_THROW( MetaInfo(events, config), wrapexcept<invalid_argument> );
 
        auto events2 = make_unique<TTree>("events2", "events");
        MetaInfo metainfo3(events2, config);
        BOOST_TEST( HashM(metainfo1) != HashM(metainfo3) );
        hash<TTree*> HashT;
        BOOST_TEST( HashT(events.get()) != HashT(events2.get()));
 
        BOOST_TEST_MESSAGE( "Testing incomplete metainfo" );
        auto events3 = make_unique<TTree>("events3", "events");
        UserInfo ui(events3.get());
        ui.Set<int>("flags", "R", 4);
        BOOST_REQUIRE_THROW( MetaInfo(events3, config), wrapexcept<invalid_argument> );
    }

BOOST_AUTO_TEST_CASE() [2/3]

BOOST_AUTO_TEST_CASE

(

git

)

Todo:

Test MetaInfo::PrintStatus

    {
        BOOST_TEST_MESSAGE( "Testing empty git path" );
        BOOST_REQUIRE_THROW( MetaInfo(MetaInfo::IKnowWhatIAmDoing{}, ""), wrapexcept<fs::filesystem_error> );
 
        BOOST_TEST_MESSAGE( "Testing wrong git path" );
        BOOST_REQUIRE_THROW( MetaInfo(MetaInfo::IKnowWhatIAmDoing{}, "/this/path/does/not/exist"), wrapexcept<fs::filesystem_error> );
 
 
        auto events = make_unique<TTree>("events", "events");
 
        pt::ptree config;
        pt::read_info(DARWIN "/test/example.info", config);
        BOOST_REQUIRE_NO_THROW( MetaInfo(events, config) );
        UserInfo ui(events.get());
        auto repo = ui.Get<string>("git", "repo"),
             commit = ui.Get<string>("git", "commit");
 
        BOOST_TEST_MESSAGE( "Testing incomplete git block (missing commit)" );
        config.put<bool>("git.complete", true);
        config.put<bool>("git.reproducible", true);
        BOOST_REQUIRE_THROW( MetaInfo(events, config), wrapexcept<pt::ptree_error> );
        config.put<string>("git.repo", repo);
        config.put<string>("git.commit", commit);
 
        BOOST_TEST_MESSAGE( "Testing inconsistent git repos" );
        config.put<fs::path>("git.repo", "/another/repo");
        BOOST_REQUIRE_NO_THROW( MetaInfo(events, config) );
        config.put<string>("git.repo", repo);
 
        BOOST_TEST_MESSAGE( "Testing inconsistent git commits" );
        config.put<string>("git.commit", "42abcd");
        BOOST_WARN_NO_THROW( MetaInfo(events, config) );
        config.put<string>("git.commit", commit);
 
        BOOST_TEST_MESSAGE( "Testing complete flag" );
        config.put<bool>("git.complete", false);
        BOOST_REQUIRE_NO_THROW( MetaInfo(events, config) );
        config.put<bool>("git.complete", true);
 
        BOOST_TEST_MESSAGE( "Testing reproducible flag" );
        config.put<bool>("git.reproducible", false);
        BOOST_REQUIRE_NO_THROW( MetaInfo(events, config) );
        config.put<bool>("git.reproducible", true);
 
        BOOST_TEST_MESSAGE( "Testing multiple git repos" );
        config.erase("git.repo");
        config.add<fs::path>("git.repo.one", "");
        config.add<fs::path>("git.repo.two", "");
        BOOST_REQUIRE_NO_THROW( MetaInfo(events, config) );
        config.get_child("git.repo").erase("one");
        config.get_child("git.repo").erase("two");
        config.get_child("git").erase("repo");
        config.add<fs::path>("git.repo", "/one/repo");
 
        BOOST_TEST_MESSAGE( "Testing multiple git commits" );
        config.erase("git.commit");
        config.add<fs::path>("git.commit.one", "123456");
        config.add<fs::path>("git.commit.two", "abcdef");
        BOOST_REQUIRE_NO_THROW( MetaInfo(events, config) );
    }

BOOST_AUTO_TEST_CASE() [3/3]

BOOST_AUTO_TEST_CASE

(

software_version

)

    {
        pt::ptree config;
        pt::read_info(DARWIN "/test/example.info", config);
        auto events = make_shared<TTree>("events", "events");
        MetaInfo metainfo(events, config);
        cout << "Forcing inconsistent version (42 everywhere)" << endl;
        metainfo.Set<const char *>("software", "gpp"  , "42");
        metainfo.Set<const char *>("software", "Cpp"  , "42");
        metainfo.Set<const char *>("software", "ROOT" , "42");
        metainfo.Set<const char *>("software", "Boost", "42");
        BOOST_REQUIRE_NO_THROW( MetaInfo{events} );
    }