IAP GITLAB

Skip to content
Snippets Groups Projects
Commit 2d630487 authored by Maximilian Reininghaus's avatar Maximilian Reininghaus :vulcan:
Browse files

delete utl/{Test.h,CMakeList.txt}

parent d0feeb54
No related branches found
No related tags found
1 merge request!38Resolve "Provide central code for Lorentz-boosts"
Hide whitespace changes
Inline Side-by-side
Framework/Utilities/CMakeList.txt deleted 100644 → 0
+ 0
− 0
View file @ d0feeb54
Framework/Utilities/Test.h deleted 100644 → 0
+ 0
− 237
View file @ d0feeb54
#ifndef _utl_Test_h_
#define _utl_Test_h_
/**
\file
Tools to do simple testing in a readable way
\author Lukas Nellen
\author Darko Veberic
\version $Id: Test.h 31925 2018-09-25 16:02:12Z darko $
\date 08 Feb 2004
\ingroup testing
*/
#include <utl/Triple.h>
#include <boost/format.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <boost/tuple/tuple_io.hpp>
#include <cmath>
namespace utl {
//! Predicate used in STL for searching for whitespace
struct IsSpace {
bool operator()(const char x) const {
return x == ' ' || x == '\r' || x == '\n' || x == '\t';
}
};
/// Predicate for equality
class Equal {
public:
template <typename T>
bool operator()(const T& lhs, const T& rhs) const {
return lhs == rhs;
}
static const char* Name() { return "equal"; }
};
/// Predicate for less
class Less {
public:
template <typename T>
bool operator()(const T& lhs, const T& rhs) const {
return lhs < rhs;
}
static const char* Name() { return "less"; }
};
/// Predicate for less or equal
class LessOrEqual {
public:
template <typename T>
bool operator()(const T& lhs, const T& rhs) const {
return lhs <= rhs;
}
static const char* Name() { return "less or equal"; }
};
/// Predicate for greater
class Greater {
public:
template <typename T>
bool operator()(const T& lhs, const T& rhs) const {
return lhs > rhs;
}
static const char* Name() { return "greater"; }
};
/// Predicate for greater or equal
class GreaterOrEqual {
public:
template <typename T>
bool operator()(const T& lhs, const T& rhs) const {
return lhs >= rhs;
}
static const char* Name() { return "greater or equal"; }
};
/// Predicate for approximate equality (for floating point)
/** The default precision is 1e-6, but it can be changed at
construction time.
*/
class CloseTo {
public:
CloseTo(const double eps = 1e-6)
: fEpsilon(eps) {}
template <typename T>
bool operator()(const T& lhs, const T& rhs) const {
return IsCloseTo(lhs, rhs);
}
boost::format Name() const { return boost::format("close (@%g) to") % fEpsilon; }
protected:
template <typename T>
bool IsCloseAbs(const T& lhs, const T& rhs) const {
return std::abs(double(lhs) - double(rhs)) < fEpsilon;
}
bool IsCloseAbs(const utl::Triple& lhs, const utl::Triple& rhs) const {
return std::sqrt(TupleDist2(lhs, rhs)) < fEpsilon;
}
template <typename T>
bool IsCloseRel(const T& lhs, const T& rhs) const {
return 2 * std::abs(double(lhs) - double(rhs)) /
(std::abs(double(lhs)) + std::abs(double(rhs))) <
fEpsilon;
}
bool IsCloseRel(const utl::Triple& lhs, const utl::Triple& rhs) const {
return (2 * sqrt(TupleDist2(lhs, rhs)) /
(sqrt(TupleDist2(lhs, utl::Triple(0, 0, 0))) +
sqrt(TupleDist2(rhs, utl::Triple(0, 0, 0))))) < fEpsilon;
}
template <typename T>
bool IsCloseTo(const T& lhs, const T& rhs) const {
if (IsCloseAbs(lhs, rhs))
return true;
else
return IsCloseRel(lhs, rhs);
}
// tuple distance
template <typename Head, typename Tail>
static double TupleDist2(const boost::tuples::cons<Head, Tail>& lhs,
const boost::tuples::cons<Head, Tail>& rhs) {
const double t = lhs.get_head() - rhs.get_head();
return t * t + TupleDist2(lhs.get_tail(), rhs.get_tail());
}
static double TupleDist2(const boost::tuples::null_type& /*lhs*/,
const boost::tuples::null_type& /*rhs*/) {
return 0;
}
double fEpsilon;
};
class CloseAbs : public CloseTo {
public:
CloseAbs(const double eps = 1e-6)
: CloseTo(eps) {}
template <typename T>
bool operator()(const T& lhs, const T& rhs) const {
return IsCloseAbs(lhs, rhs);
}
boost::format Name() const {
return boost::format("absolutely close (@%g) to") % fEpsilon;
}
};
class CloseRel : public CloseTo {
public:
CloseRel(const double eps = 1e-6)
: CloseTo(eps) {}
template <typename T>
bool operator()(const T& lhs, const T& rhs) const {
return IsCloseRel(lhs, rhs);
}
boost::format Name() const {
return boost::format("relatively close (@%g) to") % fEpsilon;
}
};
template <typename Predicate>
class Not : public Predicate {
public:
Not()
: Predicate() {}
Not(const double eps)
: Predicate(eps) {}
template <typename T>
bool operator()(const T& x) const {
return !Predicate::operator()(x);
}
template <typename T, typename U>
bool operator()(const T& x, const U& y) const {
return !Predicate::operator()(x, y);
}
template <typename T, typename U, typename W>
bool operator()(const T& x, const U& y, const W& z) const {
return !Predicate::operator()(x, y, z);
}
static boost::format Name() { return boost::format("not-%s") % Predicate().Name(); }
};
inline utl::Triple Diff(const utl::Triple& lhs, const utl::Triple& rhs) {
return utl::Triple(lhs.get<0>() - rhs.get<0>(), lhs.get<1>() - rhs.get<1>(),
lhs.get<2>() - rhs.get<2>());
}
/// Test condition by evaluating a predicate
/** If the predicate evaluates to false, we print a failure message
with the values of the left- and right-hand side and the name of
the predicate. This information is normally not available when
using the CPPUNIT_ASSERT macro.
*/
template <class Predicate, typename T>
inline bool Test(const Predicate& pred, const T& lhs, const T& rhs) {
return pred(lhs, rhs);
}
/// Main test function
template <class Predicate, typename T>
inline bool Test(const T& lhs, const T& rhs) {
return Test(Predicate(), lhs, rhs);
}
/// Test function for predicates that take an option
template <class Predicate, typename T, typename U>
inline bool Test(const T& lhs, const T& rhs, const U& eps) {
return Test(Predicate(eps), lhs, rhs);
}
} // namespace utl
#endif
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

data privacy - impressum