TestHelpers.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <framework/logging/LogSystem.h>
 
#include <gtest/gtest.h>
 
#include <Math/Vector3D.h>
 
#include <string>
 
namespace Belle2 {
  namespace TestHelpers {
 
    class TestWithGearbox : public ::testing::Test {
 
    public:
      static void SetUpTestCase();
 
      static void TearDownTestCase();
    };
 
    class TempDirCreator {
    public:
      TempDirCreator(); 
      ~TempDirCreator(); 
      std::string getTempDir() const;
    private:
      std::string m_oldpwd; 
      std::string m_tmpdir; 
    };
  }
}
 
#define EXPECT_LOGMESSAGE(x, loglevel) \
  do { \
    int nmessages_before = Belle2::LogSystem::Instance().getMessageCounter(loglevel); \
    { \
      x; \
    } \
    int nmessages_after = Belle2::LogSystem::Instance().getMessageCounter(loglevel); \
    EXPECT_TRUE(nmessages_after > nmessages_before) << "Message of level " << #loglevel << " expected, but not found."; \
  } while(0)
 
#define EXPECT_B2FATAL(x) EXPECT_EXIT(x, ::testing::ExitedWithCode(1),"")
 
#define EXPECT_B2ERROR(x) EXPECT_LOGMESSAGE(x, Belle2::LogConfig::c_Error)
 
#define EXPECT_B2WARNING(x) EXPECT_LOGMESSAGE(x, Belle2::LogConfig::c_Warning)
 
#define EXPECT_NO_LOGMESSAGE(x, loglevel) \
  do { \
    int nmessages_before = Belle2::LogSystem::Instance().getMessageCounter(loglevel); \
    { \
      x; \
    } \
    int nmessages_after = Belle2::LogSystem::Instance().getMessageCounter(loglevel); \
    EXPECT_TRUE(nmessages_after == nmessages_before) << "Message of level " << #loglevel << " found, but non expected."; \
  } while(0)
 
#define EXPECT_NO_B2FATAL(x) EXPECT_NO_LOGMESSAGE(x, Belle2::LogConfig::c_Fatal)
 
#define EXPECT_NO_B2ERROR(x) EXPECT_NO_LOGMESSAGE(x, Belle2::LogConfig::c_Error)
 
#define EXPECT_NO_B2WARNING(x) EXPECT_NO_LOGMESSAGE(x, Belle2::LogConfig::c_Warning)
 
#define TEST_CONTEXT(message) SCOPED_TRACE([&](){std::ostringstream messageStream; messageStream << message; return messageStream.str();}())
 
 
#define EXPECT_ANGLE_NEAR(expected, actual, tolerance) EXPECT_PRED3(::Belle2::TestHelpers::angleNear, expected, actual, tolerance)
 
#define ASSERT_ANGLE_NEAR(expected, actual, tolerance) ASSERT_PRED3(::Belle2::TestHelpers::angleNear, expected, actual, tolerance)
 
#define EXPECT_SAME_SIGN(expected, actual) EXPECT_PRED2(::Belle2::TestHelpers::sameSign, expected, actual)
 
#define ASSERT_SAME_SIGN(expected, actual) ASSERT_PRED2(::Belle2::TestHelpers::sameSign, expected, actual)
 
 
#define EXPECT_POSITIVE(expected) EXPECT_PRED1(::Belle2::TestHelpers::isPositive, expected)
 
#define ASSERT_POSITIVE(expected) ASSERT_PRED1(::Belle2::TestHelpers::isPositive, expected)
 
#define EXPECT_NEGATIVE(expected) EXPECT_PRED1(::Belle2::TestHelpers::isNegative, expected)
 
#define ASSERT_NEGATIVE(expected) ASSERT_PRED1(::Belle2::TestHelpers::isNegative, expected)
 
#define EXPECT_ALL_NEAR(expected, actual, tolerance) EXPECT_PRED3(::Belle2::TestHelpers::allNear<decltype(expected)>, expected, actual, tolerance)
 
#define ASSERT_ALL_NEAR(expected, actual, tolerance) ASSERT_PRED3(::Belle2::TestHelpers::allNear<decltype(expected)>, expected, actual, tolerance)
 
class TVector3;
namespace Belle2 {
  namespace  TestHelpers {
    bool angleNear(double expected, double actual, double tolerance);
 
    bool sameSign(double expected, double actual);
 
    bool isPositive(double expected);
 
    bool isNegative(double expected);
 
    template<class T>
    bool allNear(const T& expected, const T& actual, double tolerance)
    {
      using std::fabs;
      return fabs(expected - actual) < tolerance;
    }
 
    template<>
    bool allNear<ROOT::Math::XYZVector>(const ROOT::Math::XYZVector& expected, const ROOT::Math::XYZVector& actual, double tolerance);
 
    void PrintTo(const TVector3& tVector3, ::std::ostream& output);
  }
}