[RF] More improvements to roofitcore unit tests

roofit/roofitcore/test/CMakeLists.txt

@@ -7,7 +7,7 @@
 # @author Danilo Piparo CERN, 2018
 # @author Patrick Bos, NL eScience Center, 2018
 
-ROOT_ADD_GTEST(simple simple.cxx LIBRARIES RooFitCore)
+ROOT_ADD_GTEST(testSimple testSimple.cxx LIBRARIES RooFitCore)
 ROOT_ADD_GTEST(testRooAddPdf testRooAddPdf.cxx LIBRARIES RooFitCore RooStats)
 ROOT_ADD_GTEST(testRooCacheManager testRooCacheManager.cxx LIBRARIES RooFitCore)
 ROOT_ADD_GTEST(testRooCategory testRooCategory.cxx LIBRARIES RooFitCore)
@@ -53,16 +53,16 @@ ROOT_ADD_GTEST(testRooSimultaneous testRooSimultaneous.cxx LIBRARIES RooFitCore)
 ROOT_ADD_GTEST(testRooSTLRefCountList testRooSTLRefCountList.cxx LIBRARIES RooFitCore)
 ROOT_ADD_GTEST(testLikelihoodSerial TestStatistics/testLikelihoodSerial.cxx LIBRARIES RooFitCore)
 ROOT_ADD_GTEST(testRooAbsL TestStatistics/testRooAbsL.cxx LIBRARIES RooFitCore)
-ROOT_ADD_GTEST(testRooRealL TestStatistics/RooRealL.cpp LIBRARIES RooFitCore)
-ROOT_ADD_GTEST(testInterface TestStatistics/testInterface.cpp LIBRARIES RooFitCore)
+ROOT_ADD_GTEST(testRooRealL TestStatistics/testRooRealL.cxx LIBRARIES RooFitCore)
+ROOT_ADD_GTEST(testInterface TestStatistics/testInterface.cxx LIBRARIES RooFitCore)
 ROOT_ADD_GTEST(testGlobalObservables testGlobalObservables.cxx LIBRARIES RooFitCore)
 ROOT_ADD_GTEST(testRooPolyFunc testRooPolyFunc.cxx LIBRARIES Gpad RooFitCore)
 ROOT_ADD_GTEST(testSumW2Error testSumW2Error.cxx LIBRARIES Gpad RooFitCore)
 ROOT_ADD_GTEST(testRooHist testRooHist.cxx LIBRARIES RooFitCore)
 if (roofit_multiprocess)
-  ROOT_ADD_GTEST(testTestStatisticsPlot TestStatistics/testPlot.cpp LIBRARIES RooFitMultiProcess RooFitCore RooFit
+  ROOT_ADD_GTEST(testTestStatisticsPlot TestStatistics/testPlot.cxx LIBRARIES RooFitMultiProcess RooFitCore RooFit
                    COPY_TO_BUILDDIR ${CMAKE_CURRENT_SOURCE_DIR}/TestStatistics/TestStatistics_ref.root)
-  ROOT_ADD_GTEST(testLikelihoodGradientJob TestStatistics/testLikelihoodGradientJob.cpp LIBRARIES RooFitMultiProcess RooFitCore m)
+  ROOT_ADD_GTEST(testLikelihoodGradientJob TestStatistics/testLikelihoodGradientJob.cxx LIBRARIES RooFitMultiProcess RooFitCore m)
   target_include_directories(testLikelihoodGradientJob PRIVATE ${RooFitCore_MultiProcess_TestStatistics_INCLUDE_DIR})
   ROOT_ADD_GTEST(testLikelihoodJob TestStatistics/testLikelihoodJob.cxx LIBRARIES RooFitMultiProcess RooFitCore m)
   target_include_directories(testLikelihoodJob PRIVATE ${RooFitCore_MultiProcess_TestStatistics_INCLUDE_DIR})

roofit/roofitcore/test/TestStatistics/testInterface.cpp → roofit/roofitcore/test/TestStatistics/testInterface.cxx

@@ -17,9 +17,10 @@
 #include <RooWorkspace.h>
 #include <RooAbsPdf.h>
 #include <RooAbsReal.h>
+#include <RooArgSet.h>
 #include <RooDataSet.h>
+#include <RooHelpers.h>
 #include <RooRealVar.h>
-#include <RooArgSet.h>
 #include <RooGlobalFunc.h>
 #include <RooFitResult.h>
 
@@ -36,18 +37,19 @@ TEST(Interface, createNLLRooAbsL)
 
    RooRandom::randomGenerator()->SetSeed(42);
    RooWorkspace w;
-   w.factory("Gaussian::g(x[-5,5],mu[0,-3,3],sigma[1])");
-   auto x = w.var("x");
+   w.factory("Gaussian::g(x[-5,5],mu[0,-3,3],sigma[1, 0.01, 3])");
+   RooRealVar *x = w.var("x");
+   RooRealVar *sigma = w.var("sigma");
+   sigma->setConstant(true);
    RooAbsPdf *pdf = w.pdf("g");
-   std::unique_ptr<RooDataSet> data{pdf->generate(RooArgSet(*x), 10000)};
+   std::unique_ptr<RooDataSet> data{pdf->generate(*x, 10000)};
    RooAbsReal *nll = pdf->createNLL(*data, RooFit::ModularL(true));
 
-   RooFit::TestStatistics::RooRealL *nll_real = dynamic_cast<RooFit::TestStatistics::RooRealL *>(nll);
+   auto *nll_real = dynamic_cast<RooFit::TestStatistics::RooRealL *>(nll);
 
    EXPECT_TRUE(nll_real != nullptr);
 
-   RooFit::TestStatistics::RooAbsL *nll_absL =
-      dynamic_cast<RooFit::TestStatistics::RooAbsL *>(nll_real->getRooAbsL().get());
+   auto *nll_absL = dynamic_cast<RooFit::TestStatistics::RooAbsL *>(nll_real->getRooAbsL().get());
 
    EXPECT_TRUE(nll_absL != nullptr);
 }
@@ -59,42 +61,62 @@ TEST(Interface, createNLLModularLAndOffset)
 
    RooRandom::randomGenerator()->SetSeed(42);
    RooWorkspace w;
-   w.factory("Gaussian::g(x[-5,5],mu[0,-3,3],sigma[1])");
-   auto x = w.var("x");
+   w.factory("Gaussian::g(x[-5,5],mu[0,-3,3],sigma[1, 0.01, 3])");
+   RooRealVar *x = w.var("x");
+   RooRealVar *sigma = w.var("sigma");
+   sigma->setConstant(true);
    RooAbsPdf *pdf = w.pdf("g");
-   std::unique_ptr<RooDataSet> data{pdf->generate(RooArgSet(*x), 10000)};
-   RooAbsReal *nll = pdf->createNLL(*data, RooFit::Offset(true), RooFit::ModularL(true));
+   std::unique_ptr<RooDataSet> data{pdf->generate(*x, 10000)};
+
+   RooHelpers::HijackMessageStream hijack(RooFit::ERROR, RooFit::InputArguments);
+
+   std::unique_ptr<RooAbsReal> nll{pdf->createNLL(*data, RooFit::Offset(true), RooFit::ModularL(true))};
+
+   EXPECT_NE(hijack.str().find("ERROR"), std::string::npos) << "Stream contents: " << hijack.str();
 
    EXPECT_TRUE(nll == nullptr);
 }
 
 // Verifies that the fitTo parallelize interface creates a valid minimization
+#ifdef R__HAS_ROOFIT_MULTIPROCESS
+TEST(Interface, fitTo)
+#else
 TEST(Interface, DISABLED_fitTo)
+#endif
 {
+   using namespace RooFit;
+
+   RooHelpers::LocalChangeMsgLevel changeMsgLvl(RooFit::WARNING);
+
    ROOT::Math::MinimizerOptions::SetDefaultMinimizer("Minuit2");
 
    RooRandom::randomGenerator()->SetSeed(42);
    RooWorkspace w;
-   w.factory("Gaussian::g(x[-5,5],mu[0,-3,3],sigma[1])");
+   w.factory("Gaussian::g(x[-5,5],mu[0,-3,3],sigma[1, 0.01, 3])");
    auto x = w.var("x");
+   RooRealVar *sigma = w.var("sigma");
+   sigma->setConstant(true);
    RooAbsPdf *pdf = w.pdf("g");
-   std::unique_ptr<RooDataSet> data{pdf->generate(RooArgSet(*x), 10000)};
+   std::unique_ptr<RooDataSet> data{pdf->generate({*x}, 10000)};
 
-   RooArgSet *values = pdf->getParameters(data.get());
+   RooArgSet values;
+   pdf->getParameters(data->get(), values);
 
-   values->add(*pdf);
+   values.add(*pdf);
 
    RooArgSet savedValues;
-   values->snapshot(savedValues);
+   values.snapshot(savedValues);
 
-   std::unique_ptr<RooFitResult> result1{pdf->fitTo(*data, RooFit::Save())};
+   std::unique_ptr<RooFitResult> result1{pdf->fitTo(*data, Save(), PrintLevel(-1))};
 
    double minNll_nominal = result1->minNll();
    double edm_nominal = result1->edm();
 
-   values->assign(savedValues);
+   values.assign(savedValues);
 
-   std::unique_ptr<RooFitResult> result2{pdf->fitTo(*data, RooFit::Save(), RooFit::Parallelize(4), RooFit::Experimental::ParallelGradientOptions(true), RooFit::Experimental::ParallelDescentOptions(true))};
+   std::unique_ptr<RooFitResult> result2{pdf->fitTo(*data, Save(), PrintLevel(-1), Parallelize(4),
+                                                    Experimental::ParallelGradientOptions(true),
+                                                    Experimental::ParallelDescentOptions(true))};
 
    double minNll_GradientJob = result2->minNll();
    double edm_GradientJob = result2->edm();

roofit/roofitcore/test/TestStatistics/testLikelihoodGradientJob.cpp → roofit/roofitcore/test/TestStatistics/testLikelihoodGradientJob.cxx

@@ -66,10 +66,8 @@ class Environment : public testing::Environment {
       _changeMsgLvl = std::make_unique<RooHelpers::LocalChangeMsgLevel>(RooFit::ERROR);
       ROOT::Math::MinimizerOptions::SetDefaultMinimizer("Minuit2");
    }
-   void TearDown() override
-   {
-      _changeMsgLvl.reset();
-   }
+   void TearDown() override { _changeMsgLvl.reset(); }
+
 private:
    std::unique_ptr<RooHelpers::LocalChangeMsgLevel> _changeMsgLvl;
 };
@@ -423,9 +421,8 @@ TEST_P(SimBinnedConstrainedTest, ConstrainedAndOffset)
 
    RooFit::MultiProcess::Config::setDefaultNWorkers(NWorkers);
 
-   std::unique_ptr<RooAbsReal> likelihoodAbsReal{pdf->createNLL(*data, Constrain(*w.var("alpha_bkg_obs_A")),
-                                                                GlobalObservables(*w.var("alpha_bkg_obs_B")),
-                                                                ModularL(true))};
+   std::unique_ptr<RooAbsReal> likelihoodAbsReal{pdf->createNLL(
+      *data, Constrain(*w.var("alpha_bkg_obs_A")), GlobalObservables(*w.var("alpha_bkg_obs_B")), ModularL(true))};
 
    RooMinimizer::Config cfg1;
    cfg1.parallelize = -1;

roofit/roofitcore/test/TestStatistics/testLikelihoodJob.cxx

@@ -48,10 +48,8 @@ class Environment : public testing::Environment {
       _changeMsgLvl = std::make_unique<RooHelpers::LocalChangeMsgLevel>(RooFit::ERROR);
       RooFit::MultiProcess::Config::setDefaultNWorkers(2);
    }
-   void TearDown() override
-   {
-      _changeMsgLvl.reset();
-   }
+   void TearDown() override { _changeMsgLvl.reset(); }
+
 private:
    std::unique_ptr<RooHelpers::LocalChangeMsgLevel> _changeMsgLvl;
 };
@@ -115,7 +113,8 @@ TEST_F(LikelihoodJobTest, UnbinnedGaussian1D)
 {
    std::tie(nll, pdf, data, values) = generate_1D_gaussian_pdf_nll(w, 10000);
    likelihood = RooFit::TestStatistics::buildLikelihood(pdf, data);
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    auto nll0 = nll->getVal();
 
@@ -129,7 +128,8 @@ TEST_F(LikelihoodJobTest, UnbinnedGaussian1DTwice)
 {
    std::tie(nll, pdf, data, values) = generate_1D_gaussian_pdf_nll(w, 10000);
    likelihood = RooFit::TestStatistics::buildLikelihood(pdf, data);
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    auto nll0 = nll->getVal();
 
@@ -147,15 +147,16 @@ TEST_F(LikelihoodJobTest, UnbinnedGaussianND)
 
    std::tie(nll, pdf, data, values) = generate_ND_gaussian_pdf_nll(w, N, 1000);
    likelihood = RooFit::TestStatistics::buildLikelihood(pdf, data);
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    auto nll0 = nll->getVal();
 
    nll_ts->evaluate();
    auto nll1 = nll_ts->getResult();
 
    EXPECT_EQ(nll0, nll1.Sum());
-//   printf("%a =?= %a\n", nll0, nll1.Sum());
+   //   printf("%a =?= %a\n", nll0, nll1.Sum());
 }
 
 TEST_F(LikelihoodJobBinnedDatasetTest, UnbinnedPdf)
@@ -165,7 +166,8 @@ TEST_F(LikelihoodJobBinnedDatasetTest, UnbinnedPdf)
    nll.reset(pdf->createNLL(*data));
 
    likelihood = RooFit::TestStatistics::buildLikelihood(pdf, data);
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    auto nll0 = nll->getVal();
 
@@ -190,7 +192,8 @@ TEST_F(LikelihoodJobBinnedDatasetTest, BinnedManualNLL)
    RooNLLVar nll_manual("nlletje", "-log(likelihood)", *pdf, *data, projDeps, extended, nll_config);
 
    likelihood = RooFit::TestStatistics::buildLikelihood(pdf, data);
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    auto nll0 = nll_manual.getVal();
 
@@ -237,7 +240,8 @@ TEST_F(LikelihoodJobTest, SimBinned)
    nll.reset(pdf->createNLL(*data));
 
    likelihood = RooFit::TestStatistics::buildLikelihood(pdf, data);
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    auto nll0 = nll->getVal();
 
@@ -285,7 +289,8 @@ TEST_F(LikelihoodJobTest, BinnedConstrained)
 
    likelihood = RooFit::TestStatistics::buildLikelihood(
       pdf, data, RooFit::TestStatistics::GlobalObservables(RooArgSet(*w.var("alpha_bkg_obs"))));
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    nll_ts->evaluate();
    auto nll1 = nll_ts->getResult();
@@ -312,7 +317,8 @@ TEST_F(LikelihoodJobTest, SimUnbinned)
    auto nll0 = nll->getVal();
 
    likelihood = RooFit::TestStatistics::buildLikelihood(pdf, data);
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    nll_ts->evaluate();
    auto nll1 = nll_ts->getResult();
@@ -343,7 +349,8 @@ TEST_F(LikelihoodJobTest, SimUnbinnedNonExtended)
    nll.reset(pdf->createNLL(*data));
 
    likelihood = RooFit::TestStatistics::buildLikelihood(pdf, data);
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    auto nll0 = nll->getVal();
 
@@ -412,7 +419,8 @@ TEST_F(LikelihoodJobSimBinnedConstrainedTest, BasicParameters)
 
    likelihood = RooFit::TestStatistics::buildLikelihood(
       pdf, data, RooFit::TestStatistics::GlobalObservables({*w.var("alpha_bkg_obs_A"), *w.var("alpha_bkg_obs_B")}));
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    nll_ts->evaluate();
    auto nll1 = nll_ts->getResult();
@@ -433,7 +441,8 @@ TEST_F(LikelihoodJobSimBinnedConstrainedTest, ConstrainedAndOffset)
    likelihood = RooFit::TestStatistics::buildLikelihood(
       pdf, data, RooFit::TestStatistics::ConstrainedParameters(RooArgSet(*w.var("alpha_bkg_obs_A"))),
       RooFit::TestStatistics::GlobalObservables(RooArgSet(*w.var("alpha_bkg_obs_B"))));
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
    nll_ts->enableOffsetting(true);
 
    nll_ts->evaluate();
@@ -472,7 +481,8 @@ TEST_F(LikelihoodJobTest, BatchedUnbinnedGaussianND)
 
    likelihood = RooFit::TestStatistics::buildLikelihood(pdf, data);
    dynamic_cast<RooFit::TestStatistics::RooUnbinnedL *>(likelihood.get())->setUseBatchedEvaluations(true);
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
 
    auto nll0 = nll->getVal();
 
@@ -482,7 +492,8 @@ TEST_F(LikelihoodJobTest, BatchedUnbinnedGaussianND)
    EXPECT_NEAR(nll0, nll1.Sum(), 1e-14 * nll0);
 }
 
-class LikelihoodJobSplitStrategies : public LikelihoodJobSimBinnedConstrainedTest, public testing::WithParamInterface<std::tuple<std::size_t, std::size_t>> {};
+class LikelihoodJobSplitStrategies : public LikelihoodJobSimBinnedConstrainedTest,
+                                     public testing::WithParamInterface<std::tuple<std::size_t, std::size_t>> {};
 
 TEST_P(LikelihoodJobSplitStrategies, SimBinnedConstrainedAndOffset)
 {
@@ -501,7 +512,8 @@ TEST_P(LikelihoodJobSplitStrategies, SimBinnedConstrainedAndOffset)
    RooFit::MultiProcess::Config::LikelihoodJob::defaultNEventTasks = std::get<0>(GetParam());
    RooFit::MultiProcess::Config::LikelihoodJob::defaultNComponentTasks = std::get<1>(GetParam());
 
-   auto nll_ts = LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
+   auto nll_ts =
+      LikelihoodWrapper::create(RooFit::TestStatistics::LikelihoodMode::multiprocess, likelihood, clean_flags);
    nll_ts->enableOffsetting(true);
 
    nll_ts->evaluate();
@@ -524,12 +536,11 @@ TEST_P(LikelihoodJobSplitStrategies, SimBinnedConstrainedAndOffset)
    EXPECT_DOUBLE_EQ(nll1.Sum(), nll2);
 }
 
-INSTANTIATE_TEST_SUITE_P(
-    SplitStrategies, LikelihoodJobSplitStrategies,
-    testing::Combine(
-        // number of event tasks:
-        testing::Values(0, 1, 2, 50, 100, 101, 102, 100000),  // the last value is larger than number of events to test that
-        // number of component tasks:
-        testing::Values(0, 1, 2, 4)  // the last value is larger than number of components
-    )
-);
+INSTANTIATE_TEST_SUITE_P(SplitStrategies, LikelihoodJobSplitStrategies,
+                         testing::Combine(
+                            // number of event tasks:
+                            testing::Values(0, 1, 2, 50, 100, 101, 102,
+                                            100000), // the last value is larger than number of events to test that
+                            // number of component tasks:
+                            testing::Values(0, 1, 2, 4) // the last value is larger than number of components
+                            ));

roofit/roofitcore/test/TestStatistics/testLikelihoodSerial.cxx

@@ -37,14 +37,9 @@ using RooFit::TestStatistics::LikelihoodWrapper;
 
 class Environment : public testing::Environment {
 public:
-   void SetUp() override
-   {
-      _changeMsgLvl = std::make_unique<RooHelpers::LocalChangeMsgLevel>(RooFit::ERROR);
-   }
-   void TearDown() override
-   {
-      _changeMsgLvl.reset();
-   }
+   void SetUp() override { _changeMsgLvl = std::make_unique<RooHelpers::LocalChangeMsgLevel>(RooFit::ERROR); }
+   void TearDown() override { _changeMsgLvl.reset(); }
+
 private:
    std::unique_ptr<RooHelpers::LocalChangeMsgLevel> _changeMsgLvl;
 };

roofit/roofitcore/test/TestStatistics/testPlot.cpp → roofit/roofitcore/test/TestStatistics/testPlot.cxx

@@ -36,10 +36,8 @@ class Environment : public testing::Environment {
       _changeMsgLvl = std::make_unique<RooHelpers::LocalChangeMsgLevel>(RooFit::ERROR);
       ROOT::Math::MinimizerOptions::SetDefaultMinimizer("Minuit2");
    }
-   void TearDown() override
-   {
-      _changeMsgLvl.reset();
-   }
+   void TearDown() override { _changeMsgLvl.reset(); }
+
 private:
    std::unique_ptr<RooHelpers::LocalChangeMsgLevel> _changeMsgLvl;
 };