Testing.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <boost/test/unit_test.hpp>
#include <functional>
#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
namespace inject {…}
 
#define PRECICE_TEST_SETUP(...) \
  BOOST_TEST_DECORATOR(*precice::testing::testSetup(__VA_ARGS__))
#define PRECICE_TEST_SETUP(...) \ …
 
#define PRECICE_TEST()                                                     \
  precice::testing::TestContext context{precice::testing::getTestSetup()}; \
  if (context.invalid) {                                                   \
    return;                                                                \
  }                                                                        \
  BOOST_TEST_MESSAGE(context.describe());                                  \
  boost::unit_test::framework::add_context(BOOST_TEST_LAZY_MSG(context.describe()), true);
#define PRECICE_TEST()                                                     \ …
 
struct WhiteboxAccessor {
  template <typename T>
  static auto impl(T &obj) -> typename std::add_lvalue_reference<decltype(*(obj._impl))>::type
  {
    return *obj._impl;
  }
  static auto impl(T &obj) -> typename std::add_lvalue_reference<decltype(*(obj._impl))>::type {…}
};
struct WhiteboxAccessor {…};
 
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 Eigen::MatrixBase<DerivedA> &A, {…}
 
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 getFullTestName();
 
std::string getTestPath();
 
class precice_testsetup_fixture : public boost::unit_test::decorator::base {
public:
  // Constructor
  explicit precice_testsetup_fixture(precice::testing::TestSetup ts)
      : testSetup(ts) {}
  explicit precice_testsetup_fixture(precice::testing::TestSetup ts) {…}
 
  precice::testing::TestSetup testSetup;
 
private:
  // decorator::base interface
  void                                  apply(boost::unit_test::test_unit &tu) override {};
  boost::unit_test::decorator::base_ptr clone() const override
  {
    return boost::unit_test::decorator::base_ptr(new precice_testsetup_fixture(*this));
  }
  boost::unit_test::decorator::base_ptr clone() const override {…}
};
class precice_testsetup_fixture : public boost::unit_test::decorator::base {…};
 
template <typename... ARGS>
auto testSetup(ARGS... args)
{
  return precice_testsetup_fixture{precice::testing::TestSetup{args...}};
}
auto testSetup(ARGS... args) {…}
 
TestSetup getTestSetup();
 
std::optional<TestSetup> getTestSetupFor(const boost::unit_test::test_unit &tu);
 
int nextMeshID();
 
void expectFile(std::string_view name);
 
template <typename... Args>
void expectFiles(Args... args)
{
  (expectFile(args), ...);
}
void expectFiles(Args... args) {…}
 
using ErrorPredicate = std::function<bool(::precice::Error)>;
 
ErrorPredicate errorContains(std::string_view substring);
 
ErrorPredicate errorMatches(std::string regex);
 
} // namespace precice::testing
 
using namespace precice::testing::inject;