Verify.h

Go to the documentation of this file.

#ifndef _tst_Verify_h_
#define _tst_Verify_h_

#include <utl/Triple.h>
#include <utl/Test.h>
#include <boost/format.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <boost/tuple/tuple_io.hpp>
#include <cmath>
#include <iostream>


namespace tst {


  template<class Predicate, typename T>
  inline
  bool
  Verify(const Predicate& pred, const T& lhs, const T& rhs)
  {
    const bool test = pred(lhs, rhs);
    if (!test)
      std::cerr << "Failure: " << lhs << " not " << pred.Name() << ' '
                << rhs << std::endl;
    return test;
  }


  inline
  bool
  Verify(const utl::CloseTo& pred, const utl::Triple& lhs, const utl::Triple& rhs)
  {
    const bool test = pred(lhs, rhs);
    if (!test)
      std::cerr << "Failure: " << lhs << " not " << pred.Name() << ' '
                << rhs << " diff: " << utl::Diff(lhs, rhs) << std::endl;
    return test;
  }


  inline
  bool
  Verify(const utl::Not<utl::CloseTo>& pred, const utl::Triple& lhs, const utl::Triple& rhs)
  {
    const bool test = pred(lhs, rhs);
    if (!test)
      std::cerr << "Failure: " << lhs << " not " << pred.Name() << ' '
                << rhs << " diff: " << utl::Diff(lhs, rhs) << std::endl;
    return test;
  }


  template<class Predicate, typename T>
  inline bool Verify(const T& lhs, const T& rhs)
  { return Verify(Predicate(), lhs, rhs); }


  template<class Predicate, typename T>
  inline bool Verify(const T& lhs, const T& rhs, const double eps)
  { return Verify(Predicate(eps), lhs, rhs); }


  inline void Expected()
  { std::cerr << "\nExpected failure: "; }

}


#endif