Testing.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <boost/test/unit_test.hpp>
#include <string>
#include <type_traits>
 
#include "math/differences.hpp"
#include "math/math.hpp"
#include "testing/TestContext.hpp"
#include "utils/IntraComm.hpp"
 
namespace precice::testing {
 
namespace bt = boost::unit_test;
 
DataID operator"" _dataID(unsigned long long n);
 
namespace inject {
using precice::testing::Require;
using precice::testing::operator""_rank;
using precice::testing::operator""_ranks;
using precice::testing::operator""_on;
using precice::testing::operator""_dataID;
} // namespace inject
 
#define PRECICE_TEST(...)                             \
  using namespace precice::testing::inject;           \
  precice::testing::TestContext context{__VA_ARGS__}; \
  if (context.invalid) {                              \
    return;                                           \
  }                                                   \
  BOOST_TEST_MESSAGE(context.describe());             \
  boost::unit_test::framework::add_context(BOOST_TEST_LAZY_MSG(context.describe()), true);
 
struct WhiteboxAccessor {
  template <typename T>
  static auto impl(T &obj) -> typename std::add_lvalue_reference<decltype(*(obj._impl))>::type
  {
    return *obj._impl;
  }
};
 
template <class DerivedA, class DerivedB>
boost::test_tools::predicate_result equals(const Eigen::MatrixBase<DerivedA> &A,
                                           const Eigen::MatrixBase<DerivedB> &B,
                                           double                             tolerance = math::NUMERICAL_ZERO_DIFFERENCE)
{
  auto approx = [tolerance](double a, double b) -> bool {
    if (std::max(std::abs(a), std::abs(b)) < tolerance) {
      return true;
    } else {
      return std::abs(a - b) <= tolerance * std::max(std::abs(a), std::abs(b));
    }
  };
 
  if (!A.binaryExpr(B, approx).all()) {
    boost::test_tools::predicate_result res(false);
    Eigen::IOFormat                     format;
    if (A.cols() == 1) {
      format.rowSeparator = ", ";
      format.rowPrefix    = "  ";
      format.precision    = Eigen::FullPrecision;
    }
    res.message() << "\n"
                  << A.format(format) << " != \n"
                  << B.format(format) << '\n'
                  << (A - B).cwiseAbs().format(format) << " difference\n"
                  << A.binaryExpr(B, approx).format(format) << "in tolerance (" << tolerance << ')';
    return res;
  }
  return true;
}
 
boost::test_tools::predicate_result equals(const std::vector<float> &VectorA,
                                           const std::vector<float> &VectorB,
                                           float                     tolerance = math::NUMERICAL_ZERO_DIFFERENCE);
 
boost::test_tools::predicate_result equals(const std::vector<double> &VectorA,
                                           const std::vector<double> &VectorB,
                                           double                     tolerance = math::NUMERICAL_ZERO_DIFFERENCE);
 
boost::test_tools::predicate_result equals(float a, float b, float tolerance = math::NUMERICAL_ZERO_DIFFERENCE);
 
boost::test_tools::predicate_result equals(double a, double b, double tolerance = math::NUMERICAL_ZERO_DIFFERENCE);
 
std::string getPathToRepository();
 
std::string getPathToSources();
 
std::string getPathToTests();
 
std::string getTestName();
 
std::string getTestPath();
 
int nextMeshID();
 
} // namespace precice::testing