RunTests.h

Go to the documentation of this file.

/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000-2005, Hammersmith Imanet Ltd
    Copyright (C) 2013, Kris Thielemans
    Copyright (C) 2013, 2020, 2022, 2023, 2024 University College London
    Copyright (C) 2018, University of Hull
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
 
    See STIR/LICENSE.txt for details
*/
 
#include "stir/VectorWithOffset.h"
#include "stir/BasicCoordinate.h"
#include "stir/IndexRange.h"
#include "stir/stream.h"
#include "stir/Bin.h"
#include "stir/DetectionPosition.h"
#include "stir/DetectionPositionPair.h"
#include "stir/ProjDataInMemory.h"
#include "stir/LORCoordinates.h"
#include <iostream>
#include <typeinfo>
#include <vector>
#include <complex>
#include <string>
 
START_NAMESPACE_STIR

class RunTests
{
public:
  explicit RunTests(const double tolerance = 1E-4);

  virtual ~RunTests();


  virtual void run_tests() = 0;

  bool is_everything_ok() const;


  int main_return_value() const;

  void set_tolerance(const double tolerance);

  double get_tolerance() const;


  bool check(const bool, const std::string& str = "");

  bool check_if_equal(const std::string& a, const std::string& b, const std::string& str = "");
  bool check_if_equal(const double a, const double b, const std::string& str = "");
  // Note: due to current C++ overloading rules, we need copies for every integer type
  bool check_if_equal(const short a, const short b, const std::string& str = "");
  bool check_if_equal(const unsigned short a, const unsigned short b, const std::string& str = "");
  bool check_if_equal(const int a, const int b, const std::string& str = "");
  bool check_if_equal(const unsigned int a, const unsigned int b, const std::string& str = "");
  bool check_if_equal(const long a, const long b, const std::string& str = "");
  bool check_if_equal(const unsigned long a, const unsigned long b, const std::string& str = "");
#ifdef BOOST_HAS_LONG_LONG
  // necessary to cope with std::size_t for instance (on 64 bit systems)
  bool check_if_equal(const long long a, const long long b, const std::string& str = "");
  bool check_if_equal(const unsigned long long a, const unsigned long long b, const std::string& str = "");
#endif
  bool check_if_equal(const Bin& a, const Bin& b, const std::string& str = "")
  {
    return this->check_if_equal_generic(a, b, str);
  }
  template <class T>
  bool check_if_equal(const DetectionPosition<T>& a, const DetectionPosition<T>& b, const std::string& str = "")
  {
    return this->check_if_equal_generic(a, b, str);
  }
  template <class T>
  bool check_if_equal(const DetectionPositionPair<T>& a, const DetectionPositionPair<T>& b, const std::string& str = "")
  {
    return this->check_if_equal_generic(a, b, str);
  }
  template <class T>
  bool check_if_equal(const LORInAxialAndNoArcCorrSinogramCoordinates<T>& a,
                      const LORInAxialAndNoArcCorrSinogramCoordinates<T>& b,
                      const std::string& str = "");
 
  // VC 6.0 needs definition of template members in the class def unfortunately.
  template <class T>
  bool check_if_equal(const std::complex<T> a, const std::complex<T> b, const std::string& str = "")
  {
    return check_if_equal(a.real(), b.real(), str) && check_if_equal(a.imag(), b.imag(), str);
  }

  template <class T>
  bool check_if_equal(const VectorWithOffset<T>& t1, const VectorWithOffset<T>& t2, const std::string& str = "")
  {
    if (t1.get_min_index() != t2.get_min_index() || t1.get_max_index() != t2.get_max_index())
      {
        std::cerr << "Error: unequal ranges. " << str << std::endl;
        return everything_ok = false;
      }
 
    for (int i = t1.get_min_index(); i <= t1.get_max_index(); i++)
      {
        if (!check_if_equal(t1[i], t2[i], str))
          {
            std::cerr << "(at VectorWithOffset<" << typeid(T).name() << "> first mismatch at index " << i << ")\n";
            return everything_ok = false;
          }
      }
    return true;
  }
  // VC 6.0 needs definition of template members in the class def unfortunately.
  template <class T>
  bool check_if_equal(const std::vector<T>& t1, const std::vector<T>& t2, const std::string& str = "")
  {
    if (t1.size() != t2.size())
      {
        std::cerr << "Error: unequal ranges. " << str << std::endl;
        return everything_ok = false;
      }
 
    bool all_equal = true;
    for (unsigned int i = 0; i < t1.size(); i++)
      {
        if (!check_if_equal(t1[i], t2[i], str))
          {
            std::cerr << "(at vector<" << typeid(T).name() << ">  mismatch at index " << i << ")\n";
            all_equal = false;
          }
      }
    return all_equal;
  }
 
  bool check_if_equal(const ProjDataInMemory& t1, const ProjDataInMemory& t2, const std::string& str = "");
 
  // VC 6.0 needs definition of template members in the class def unfortunately.
  template <int n>
  bool check_if_equal(const IndexRange<n>& t1, const IndexRange<n>& t2, const std::string& str = "")
  {
    if (t1 != t2)
      {
        std::cerr << "Error: unequal ranges. " << str << std::endl;
        return everything_ok = false;
      }
    else
      return true;
  }
  template <int num_dimensions, class coordT>
  bool check_if_equal(const BasicCoordinate<num_dimensions, coordT>& a,
                      const BasicCoordinate<num_dimensions, coordT>& b,
                      const std::string& str = "")
  {
    if (norm(a - b) > tolerance)
      {
        std::cerr << "Error : Unequal Coordinate value are " << a << " and " << b << ". " << str << std::endl;
        everything_ok = false;
        return false;
      }
    else
      return true;
  }


  bool check_if_zero(const double a, const std::string& str = "");
  bool check_if_zero(const short a, const std::string& str = "");
  bool check_if_zero(const unsigned short a, const std::string& str = "");
  bool check_if_zero(const int a, const std::string& str = "");
  bool check_if_zero(const unsigned int a, const std::string& str = "");
  bool check_if_zero(const long a, const std::string& str = "");
  bool check_if_zero(const unsigned long a, const std::string& str = "");
#ifdef BOOST_HAS_LONG_LONG
  bool check_if_zero(const long long a, const std::string& str = "");
  bool check_if_zero(const unsigned long long a, const std::string& str = "");
#endif
 
  // VC needs definition of template members in the class def unfortunately.
  template <class T>
  bool check_if_zero(const VectorWithOffset<T>& t, const std::string& str = "")
  {
    for (int i = t.get_min_index(); i <= t.get_max_index(); i++)
      {
        if (!check_if_zero(t[i], str))
          {
            std::cerr << "(at VectorWithOffset<" << typeid(T).name() << "> first mismatch at index " << i << ")\n";
            return false;
          }
      }
    return true;
  }

  template <int num_dimensions, class coordT>
  bool check_if_zero(const BasicCoordinate<num_dimensions, coordT>& a, const std::string& str = "")
  {
    if (norm(a) > tolerance)
      {
        std::cerr << "Error : Coordinate value is " << a << " expected 0s. " << str << std::endl;
        everything_ok = false;
        return false;
      }
    else
      return true;
  }


  template <class T1, class T2>
  inline bool check_if_less(T1 a, T2 b, const std::string& str = "");
 
protected:
  double tolerance;
  bool everything_ok;

  template <class T>
  bool check_if_equal_generic(const T& a, const T& b, const std::string& str)
  {
    if (a != b)
      {
        std::cerr << "Error : unequal values are \n\t" << a << "\n\tand\n\t" << b << "\n\t" << str << std::endl;
        everything_ok = false;
        return false;
      }
    else
      return true;
  }

  template <class T>
  bool check_if_zero_generic(T a, const std::string& str)
  {
    if ((a != static_cast<T>(0)))
      {
        std::cerr << "Error : 0 value is " << a << " ." << str << std::endl;
        everything_ok = false;
        return false;
      }
    else
      return true;
  }
};
 
END_NAMESPACE_STIR
 
START_NAMESPACE_STIR
 
RunTests::RunTests(const double tolerance)
    : tolerance(tolerance),
      everything_ok(true)
{}
 
RunTests::~RunTests()
{
#if defined(_DEBUG) && defined(__MSL__)
  DebugNewReportLeaks();
#endif
 
  if (everything_ok)
    std::cerr << "\nAll tests ok !\n\n" << std::endl;
  else
    std::cerr << "\nEnd of tests. Please correct errors !\n\n" << std::endl;
}
 
bool
RunTests::is_everything_ok() const
{
  return everything_ok;
}
 
int
RunTests::main_return_value() const
{
  return everything_ok ? EXIT_SUCCESS : EXIT_FAILURE;
}
 
void
RunTests::set_tolerance(const double tolerance_v)
{
  tolerance = tolerance_v;
}
 
double
RunTests::get_tolerance() const
{
  return tolerance;
}
 
bool
RunTests::check(const bool result, const std::string& str)
{
  if (!result)
    {
      std::cerr << "Error. " << str << std::endl;
      everything_ok = false;
    }
  return result;
}
 
bool
RunTests::check_if_equal(const std::string& a, const std::string& b, const std::string& str)
{
  return this->check_if_equal_generic(a, b, str);
}

bool
RunTests::check_if_equal(const double a, const double b, const std::string& str)
{
  const double diff = fabs(b - a);
  if (diff <= tolerance)
    return true;
 
  const double largest = (std::max(fabs(b), fabs(a)));
 
  if (diff > tolerance * largest)
    {
      std::cerr << "Error : unequal values are " << a << " and " << b << ". " << str << std::endl;
      everything_ok = false;
      return false;
    }
  else
    return true;
}
 
bool
RunTests::check_if_equal(const short a, const short b, const std::string& str)
{
  return this->check_if_equal_generic(a, b, str);
}
bool
RunTests::check_if_equal(const unsigned short a, const unsigned short b, const std::string& str)
{
  return this->check_if_equal_generic(a, b, str);
}
bool
RunTests::check_if_equal(const int a, const int b, const std::string& str)
{
  return this->check_if_equal_generic(a, b, str);
}
bool
RunTests::check_if_equal(const unsigned int a, const unsigned int b, const std::string& str)
{
  return this->check_if_equal_generic(a, b, str);
}
bool
RunTests::check_if_equal(const long a, const long b, const std::string& str)
{
  return this->check_if_equal_generic(a, b, str);
}
bool
RunTests::check_if_equal(const unsigned long a, const unsigned long b, const std::string& str)
{
  return this->check_if_equal_generic(a, b, str);
}
#ifdef BOOST_HAS_LONG_LONG
bool
RunTests::check_if_equal(const long long a, const long long b, const std::string& str)
{
  return this->check_if_equal_generic(a, b, str);
}
bool
RunTests::check_if_equal(const unsigned long long a, const unsigned long long b, const std::string& str)
{
  return this->check_if_equal_generic(a, b, str);
}
#endif
 
template <class T>
bool
RunTests::check_if_equal(const LORInAxialAndNoArcCorrSinogramCoordinates<T>& a,
                         const LORInAxialAndNoArcCorrSinogramCoordinates<T>& b,
                         const std::string& str)
{
  bool ok = this->check_if_equal(a.radius(), b.radius(), str + ": radius") && this->check_if_equal(a.z1(), b.z1(), str + ": z1")
            && this->check_if_equal(a.z2(), b.z2(), str + ": z2") && this->check_if_equal(a.beta(), b.beta(), str + ": beta")
            && this->check_if_equal(a.phi(), b.phi(), str + ": phi")
            && this->check_if_equal(a.is_swapped(), b.is_swapped(), str + ": is_swapped");
  if (!ok)
    std::cerr << "\t(comparing " << a << " and " << b << ")\n";
  return ok;
}
 
bool
RunTests::check_if_equal(const ProjDataInMemory& t1, const ProjDataInMemory& t2, const std::string& str)
{
  if (*t1.get_proj_data_info_sptr() != *t2.get_proj_data_info_sptr())
    {
      std::cerr << "Error: unequal proj_data_info. " << str << std::endl;
      return everything_ok = false;
    }
 
  for (auto i1 = t1.begin(), i2 = t2.begin(); i1 != t1.end(); ++i1, ++i2)
    {
      if (!check_if_equal(*i1, *i2, str))
        {
          return everything_ok = false;
        }
    }
  return true;
}
 
bool
RunTests::check_if_zero(const short a, const std::string& str)
{
  return this->check_if_zero_generic(a, str);
}
bool
RunTests::check_if_zero(const unsigned short a, const std::string& str)
{
  return this->check_if_zero_generic(a, str);
}
bool
RunTests::check_if_zero(const int a, const std::string& str)
{
  return this->check_if_zero_generic(a, str);
}
bool
RunTests::check_if_zero(const unsigned int a, const std::string& str)
{
  return this->check_if_zero_generic(a, str);
}
bool
RunTests::check_if_zero(const long a, const std::string& str)
{
  return this->check_if_zero_generic(a, str);
}
bool
RunTests::check_if_zero(const unsigned long a, const std::string& str)
{
  return this->check_if_zero_generic(a, str);
}
#ifdef BOOST_HAS_LONG_LONG
bool
RunTests::check_if_zero(const long long a, const std::string& str)
{
  return this->check_if_zero_generic(a, str);
}
bool
RunTests::check_if_zero(const unsigned long long a, const std::string& str)
{
  return this->check_if_zero_generic(a, str);
}
#endif

bool
RunTests::check_if_zero(const double a, const std::string& str)
{
  if (fabs(a) > tolerance)
    {
      std::cerr << "Error : 0 value is " << a << " ." << str << std::endl;
      everything_ok = false;
      return false;
    }
  else
    return true;
}
 
template <class T1, class T2>
bool
RunTests::check_if_less(T1 a, T2 b, const std::string& str)
{
  if (a >= b)
    {
      std::cerr << "Error : " << a << " is larger than " << b << ", " << str << std::endl;
      everything_ok = false;
      return false;
    }
  else
    return true;
}
 
END_NAMESPACE_STIR