test_system.hpp

Go to the documentation of this file.

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
#pragma once
 
// includes, FEAT
#include <kernel/base_header.hpp>
#include <kernel/backend.hpp>
#include <kernel/util/type_traits.hpp>
#include <kernel/util/exception.hpp>
#include <kernel/util/math.hpp>
 
// includes, system
#include <string>
#include <exception>
#include <list>
#include <typeinfo>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <cmath>
 
#define CHECK_INTERNAL(was_ok, message)\
        if(! (was_ok))\
          throw FEAT::TestSystem::TestFailedException(__func__, __FILE__, __LINE__, message);
 
namespace FEAT
{
  namespace TestSystem
  {
    // Forward declaration
    class UnitTest;
 
    class TestFailedException
      : public std::exception
    {
 
    private:
 
      const String _message;
 
 
    public:
 
      TestFailedException(
          const char* const function,
          const char* const file,
          const long line,
          const String & message)
        : _message(stringify(file) + ":" + stringify(line) + ": in " + stringify(function) + ": " + message )
      {
      }
 
      virtual ~TestFailedException() noexcept
      {
      }
 
      virtual const char* what() const noexcept override
      {
        return _message.c_str();
      }
    }; // class TestFailedException
 
    class TestList
    {
    private:
      class DeleteOnDestruction
      {
      private:
        TestList * * const _ptr;
 
      public:
        explicit DeleteOnDestruction(TestList * * const ptr)
          : _ptr(ptr)
        {
        }
 
        ~DeleteOnDestruction()
        {
          TestList::_delete(*_ptr);
          *_ptr = nullptr;
        }
      };
 
      static TestList * * _instance_ptr()
      {
        // The Microsoft compiler warns that creating a local static object is not thread-safe.
        // The corresponding warning is enabled by default, so we'll only disable it for the following
        // code and restore the warning state afterwards.
#ifdef FEAT_COMPILER_MICROSOFT
#  pragma warning(push)
#  pragma warning(disable: 4640)
#endif
 
        static TestList * instance(nullptr);
        static DeleteOnDestruction delete_instance(&instance);
 
#ifdef FEAT_COMPILER_MICROSOFT
#  pragma warning(pop)
#endif
 
        return &instance;
      }
 
      static void _delete(TestList * const ptr)
      {
        delete ptr;
      }
 
      std::list<UnitTest*> _tests;
 
      TestList()
      {
      }
 
      TestList(const TestList&) = delete;
      TestList& operator=(const TestList&) = delete;
 
    public:
      static TestList * instance()
      {
        TestList * * instance_ptr = _instance_ptr();
 
        if (nullptr == *instance_ptr)
        {
          //static Mutex m;
          //Lock l(m);
 
          instance_ptr = _instance_ptr();
 
          if (nullptr == *instance_ptr)
          {
            *instance_ptr = new TestList;
          }
        }
        return *instance_ptr;
      }
 
      typedef std::list<UnitTest*>::iterator Iterator;
 
      void register_test(UnitTest* const test)
      {
        _tests.push_back(test);
      }
 
      Iterator begin_tests()
      {
        return _tests.begin();
      }
 
      Iterator end_tests()
      {
        return _tests.end();
      }
 
      size_t size()
      {
        return _tests.size();
      }
 
      Iterator erase (Iterator i)
      {
        return _tests.erase(i);
      }
    }; // class TestList
 
 
    class UnitTest
    {
    protected:
 
      const String _id;
      String _datatype_name;
      String _index_name;
      PreferredBackend _preferred_backend;
 
 
    public:
 
      explicit UnitTest(const String& id_in, const String& datatype_name = "none", const String& index_name = "none", PreferredBackend preferred_backend = PreferredBackend::generic)
        : _id(id_in),
        _datatype_name(datatype_name),
        _index_name(index_name),
        _preferred_backend(preferred_backend)
      {
        TestList::instance()->register_test(this);
      }
 
      virtual ~UnitTest() {}
 
      virtual const String id() const
      {
        return _id;
      }
 
      virtual void check(const char * const function, const char * const file,
          const long line, bool was_ok, const String & message) const
      {
        if(! was_ok)
          throw TestFailedException(function, file, line, message);
      }
 
      virtual void run() const = 0;
 
      virtual String get_datatype_name()
      {
        return _datatype_name;
      }
 
      virtual String get_index_name()
      {
        return _index_name;
      }
 
      virtual PreferredBackend get_preferred_backend() const
      {
        return _preferred_backend;
      }
 
      virtual String get_preferred_backend_name() const
      {
        return stringify(_preferred_backend);
      }
    }; // class UnitTest
 
    template<typename DT_>
    DT_ tol()
    {
      return Math::pow(Math::eps<DT_>(), DT_(0.7));
    }
 
    template<>
    inline double tol<double>()
    {
      return Math::pow(Math::eps<double>(), 0.7);
    }
 
    template<>
    inline float tol<float>()
    {
      return Math::pow(Math::eps<float>(), 0.7F);
    }
 
#ifdef FEAT_HAVE_QUADMATH
    template<>
    inline __float128 tol<__float128>()
    {
      return Math::pow(Math::eps<__float128>(), __float128(0.7));
    }
#endif
 
#ifdef FEAT_HAVE_HALFMATH
    template<>
    inline Half tol<Half>()
    {
      return Math::pow(Math::eps<Half>(), Half(0.35));
    }
#endif
 
    template<typename DT_>
    DT_ relaxed_tol()
    {
      return Math::pow(Math::eps<DT_>(), DT_(0.4));
    }
 
    template<>
    inline double relaxed_tol<double>()
    {
      return Math::pow(Math::eps<double>(), 0.4);
    }
 
    template<>
    inline float relaxed_tol<float>()
    {
      return Math::pow(Math::eps<float>(), 0.3F);
    }
 
#ifdef FEAT_HAVE_QUADMATH
    template<>
    inline __float128 relaxed_tol<__float128>()
    {
      return Math::pow(Math::eps<__float128>(), __float128(0.4));
    }
#endif
 
#ifdef FEAT_HAVE_HALFMATH
    template<>
    inline Half relaxed_tol<Half>()
    {
      return Math::pow(Math::eps<Half>(), Half(0.2));
    }
#endif
 
  } // namespace TestSystem
} // namespace FEAT
#define TEST_CHECK_EQUAL(a, b) \
  do { \
    CHECK_INTERNAL((a)==(b), this->_id + "\n" +  "Expected '" #a "' to equal \n'" + FEAT::stringify(b) + "'\nbut got\n'" + FEAT::stringify(a) + "'")\
  } while (false)
 
#define TEST_CHECK_NOT_EQUAL(a, b) \
  do { \
    CHECK_INTERNAL(!((a)==(b)), this->_id + "\n" +  "Expected '" #a "' that is'" + FEAT::stringify(a) + "' to equal not '" + FEAT::stringify(b) + "'")\
  } while (false)
 
#define TEST_CHECK_IN_RANGE(x, a, b) \
  do { \
    CHECK_INTERNAL(((a) <= (x)) && ((x) <= (b)), this->_id + "\n" +  "Expected '" #x "' that is'" + FEAT::stringify(x) + "' to be in range [" + FEAT::stringify(a) + "," + FEAT::stringify(b) + "]")\
  } while (false)
 
#define TEST_CHECK_STRINGIFY_EQUAL(a, b) \
  do { \
    String s_a(FEAT::stringify(a)); \
    String s_b(FEAT::stringify(b)); \
    CHECK_INTERNAL(s_a == s_b, this->_id + "\n" +  "Expected '" #a "' to equal '" + s_b + "'\nbut got\n'" + s_a + "'")\
  } while (false)
 
#define TEST_CHECK(a) \
  do { \
    CHECK_INTERNAL(a, this->_id + "\n" +  "Check '" #a "' failed") \
  } while (false)
 
#define TEST_CHECK_MSG(a,msg) \
  do { \
    CHECK_INTERNAL(a, this->_id + "\n" + (msg))\
  } while (false)
 
#define TEST_CHECK_THROWS(a, b) \
  do { \
    try { \
      try { \
        a; \
        this->check(__func__, __FILE__, __LINE__, false, \
            this->_id + "\n" +  "Expected exception of type '" #b "' not thrown"); \
      } catch (b &) { \
        TEST_CHECK(true); \
      } \
    } catch (const FEAT::TestSystem::TestFailedException &) { \
      throw; \
    } catch (const std::exception & test_e) { \
      throw FEAT::TestSystem::TestFailedException(__func__, __FILE__, __LINE__, \
          "Test threw unexpected exception "+ FEAT::stringify(test_e.what()) + \
          " inside a TEST_CHECK_THROWS block"); \
    } catch (...) { \
      throw FEAT::TestSystem::TestFailedException(__func__, __FILE__, __LINE__, \
          "Test threw unexpected unknown exception inside a TEST_CHECK_THROWS block"); \
    } \
  } while (false)
 
#define TEST_CHECK_EQUAL_WITHIN_EPS(a, b, eps) \
  do { \
    CHECK_INTERNAL(((a) <= ((b) + (eps))) && ((b) <= ((a) + (eps))), \
        this->_id + "\n" + "Expected '|" #a " - " #b \
        "|' <= '" + FEAT::stringify(eps) + "' but was '" + \
        FEAT::stringify((a) < (b) ? (b) - (a) : (a) - (b)) + "'" \
        + ", with " #a "=" + FEAT::stringify(a) + " and " #b "=" + FEAT::stringify(b))\
  } while (false)
 
#define TEST_CHECK_RELATIVE(a, b, eps) \
  do { \
    CHECK_INTERNAL(Math::abs((a) - (b)) <= (eps)*Math::abs(b), \
        this->_id + "\n" + "Expected '|" #a " - " #b \
        "|' <= '" + FEAT::stringify(eps) + "*|" #b "|' = '" + \
        FEAT::stringify((eps)*Math::abs(b)) + "' but was '" + \
        FEAT::stringify(Math::abs((a) - (b))) + "'" \
        + ", with " #a "=" + FEAT::stringify(a) + " and " #b "=" + FEAT::stringify(b))\
  } while (false)
 
#define TEST_CHECK_LESS_THAN(a, b) \
  do { \
    CHECK_INTERNAL((a) < (b), this->_id + "\n" +  "Expected '" #a "' to be less than \n'" + FEAT::stringify(b) + "'\nbut got\n'" + FEAT::stringify(a) + "'")\
  } while (false)
 
#define TEST(pre, test, post) \
  do { \
    pre; \
    try { \
      test; \
    } catch (const FEAT::TestSystem::TestFailedException & test_e) { \
      post; \
      throw; } \
    post; \
  } while (false)