Assert.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Commons/Io/File.hpp"
#include <boost/test/unit_test.hpp>
#include <cmath>
 
namespace Arp { namespace System { namespace Commons { namespace Testing
{
 
class Assert
{
private: // deleted construction/destruction
    Assert(void) = delete;
    ~Assert(void) = delete;
 
public: // AreEqual operations
    static void     AreEqual(const void* expected, const void* actual);
    static void     AreEqual(const char* expected, const char* actual);
    static void     AreEqual(const char* expected, const String& actual);
    static void     AreEqual(const String& expected, const char* actual);
    static void     AreEqual(char expected, char actual);
    static void     AreEqual(unsigned char expected, unsigned char actual);
    static void     AreEqual(float expected, float actual, float epsilon);
    static void     AreEqual(double expected, double actual, double epsilon);
    template<typename... Args>
    static void     AreEqual(float expected, float actual, float epsilon, const char* message, const Args& ... args);
    template<typename... Args>
    static void     AreEqual(double expected, double actual, double epsilon, const char* message, const Args& ... args);
    template<class T>
    static void     AreEqual(const T& expected, const T& actual);
    template<class T, typename... Args>
    static void     AreEqual(const T& expected, const T& actual, const char* message, const Args& ... args);
 
public: // AreNotEqual operations
    static void     AreNotEqual(float notExpected, float actual, float epsilon);
    static void     AreNotEqual(double notExpected, double actual, double epsilon);
    template<typename... Args>
    static void     AreNotEqual(float notExpected, float actual, float epsilon, const char* message, const Args& ... args);
    template<typename... Args>
    static void     AreNotEqual(double notExpected, double actual, double epsilon, const char* message, const Args& ... args);
    template<class T>
    static void     AreNotEqual(const T& notExpected, const T& actual);
    template<class T, typename... Args>
    static void     AreNotEqual(const T& notExpected, const T& actual, const char* message, const Args& ... args);
 
public: // Fail operations
    template<typename ... Args>
    static void     Error(const char* message, const Args& ... args);
    template<typename ... Args>
    static void     Fail(const char* message, const Args& ... args);
 
public: // IsTrue operations
    template<class Predicate>
    static void     IsTrue(Predicate predicate);
    template<class Predicate, typename... Args>
    static void     IsTrue(Predicate predicate, const char* message, const Args& ... args);
 
public: // IsFalse operations
    template<class Predicate>
    static void     IsFalse(Predicate predicate);
    template<class Predicate, typename... Args>
    static void     IsFalse(Predicate predicate, const char* message, const Args& ... args);
 
public: // IsNull operations
    template<class T>
    static void     IsNull(T* pValue);
    template<class T, typename... Args>
    static void     IsNull(T* pValue, const char* message, const Args& ... args);
 
public: // IsNotNull operations
    template<class T>
    static void     IsNotNull(T* pValue);
    template<class T, typename... Args>
    static void     IsNotNull(T* pValue, const char* message, const Args& ... args);
 
public: // IsEmpty operations
    static void     IsEmpty(const String& s);
    template<typename... Args>
    static void     IsEmpty(const String& s, const char* message, const Args& ... args);
 
public: // IsNotEmpty operations
    static void     IsNotEmpty(const String& s);
    template<typename... Args>
    static void     IsNotEmpty(const String& s, const char* message, const Args& ... args);
 
public: // Exists operations
    static void     Exists(const String& path);
    template<typename... Args>
    static void     Exists(const String& path, const char* message, const Args& ... args);
 
public: // NotExists operations
    static void     NotExists(const String& path);
    template<typename... Args>
    static void     NotExists(const String& path, const char* message, const Args& ... args);
 
public: // IsInstanceOf operations
    template<class TExpected, class T>
    static void     IsInstanceOfType(const T& instance);
    template<class TExpected, class T, typename... Args>
    static void     IsInstanceOfType(const T& instance, const char* message, const Args& ... args);
    template<class TExpected, class T>
    static void     IsInstanceOfType(const T* pInstance);
    template<class TExpected, class T, typename... Args>
    static void     IsInstanceOfType(const T* pInstance, const char* message, const Args& ... args);
 
public: // IsNotInstanceOfType operations
    template<class TExpected, class T>
    static void     IsNotInstanceOfType(const T& instance);
    template<class TExpected, class T, typename... Args>
    static void     IsNotInstanceOfType(const T& instance, const char* message, const Args& ... args);
    template<class TExpected, class T>
    static void     IsNotInstanceOfType(const T* pInstance);
    template<class TExpected, class T, typename... Args>
    static void     IsNotInstanceOfType(const T* pInstance, const char* message, const Args& ... args);
 
public: // Throws operations
    template<typename TException, typename TFunction>
    static void Throws(TFunction&& func);
    template<typename TException, typename TFunction>
    static void Throws(const char* message, TFunction&& func);
 
private: // methods
    static void CheckInternal(bool predicate, const char* message);
    static void ErrorInternal(const char* message);
    static void FailInternal(const char* message);
 
private: // static/const fields
    static const char* const areEqualDefaultMessage;
    static const char* const areEqualDefaultMessageIntegersInHex;
    static const char* const areNotEqualDefaultMessage;
    static const char* const isTrueDefaultMessage;
    static const char* const isFalseDefaultMessage;
    static const char* const isNullDefaultMessage;
    static const char* const isNotNullDefaultMessage;
    static const char* const isEmptyDefaultMessage;
    static const char* const isNotEmptyDefaultMessage;
    static const char* const existsDefaultMessage;
    static const char* const notExistsDefaultMessage;
    static const char* const isInstanceOfTypeDefaultMessage;
    static const char* const isNotInstanceOfTypeDefaultMessage;
    static const char* const throwsNotDefaultMessage;
    static const char* const throwsWrongTypeOfExceptionDefaultMessage;
};
 
// inline methods of static class Assert
 
// Assert::AreEqual() operations
inline void Assert::AreEqual(const void* expected, const void* actual)
{
    if (expected == nullptr && actual == nullptr)
    {
        return;
    }
    if (expected == nullptr && actual != nullptr)
    {
        Assert::Fail(areEqualDefaultMessageIntegersInHex, 0, actual);
        return;
    }
    if (expected != nullptr && actual == nullptr)
    {
        Assert::Fail(areEqualDefaultMessage, expected, 0);
        return;
    }
    Assert::CheckInternal(expected == actual, String::Format(areEqualDefaultMessageIntegersInHex, expected, actual));
}
 
inline void Assert::AreEqual(const char* expected, const char* actual)
{
    if (expected == nullptr && actual == nullptr)
    {
        return;
    }
    if (expected == nullptr && actual != nullptr)
    {
        Assert::Fail(areEqualDefaultMessage, "", actual);
        return;
    }
    if (expected != nullptr && actual == nullptr)
    {
        Assert::Fail(areEqualDefaultMessage, expected, "");
        return;
    }
    Assert::CheckInternal(String(expected) == actual, String::Format(areEqualDefaultMessage, expected, actual));
}
 
inline void Assert::AreEqual(const char* expected, const String& actual)
{
    Assert::CheckInternal(expected == actual, String::Format(areEqualDefaultMessage, expected, actual));
}
 
inline void Assert::AreEqual(const String& expected, const char* actual)
{
    Assert::CheckInternal(expected == actual, String::Format(areEqualDefaultMessage, expected, actual));
}
 
inline void Assert::AreEqual(char expected, char actual)
{
    Assert::CheckInternal(expected == actual, String::Format(areEqualDefaultMessageIntegersInHex, static_cast<int>(expected), static_cast<int>(actual)));
}
 
inline void Assert::AreEqual(unsigned char expected, unsigned char actual)
{
    Assert::CheckInternal(expected == actual, String::Format(areEqualDefaultMessageIntegersInHex, static_cast<int>(expected), static_cast<int>(actual)));
}
 
inline void Assert::AreEqual(float expected, float actual, float epsilon)
{
    if (std::abs(actual - expected) > std::abs(epsilon))
    {
        Assert::FailInternal(String::Format(areEqualDefaultMessage, expected, actual));
    }
}
 
inline void Assert::AreEqual(double expected, double actual, double epsilon)
{
    if (std::abs(actual - expected) > std::abs(epsilon))
    {
        Assert::FailInternal(String::Format(areEqualDefaultMessage, expected, actual));
    }
}
 
template<typename... Args>
inline void Assert::AreEqual(float expected, float actual, float epsilon, const char* message, const Args& ... args)
{
    if (std::abs(actual - expected) > std::abs(epsilon))
    {
        Assert::FailInternal(String::Format(message, args...));
    }
}
 
template<typename... Args>
inline void Assert::AreEqual(double expected, double actual, double epsilon, const char* message, const Args& ... args)
{
    if (std::abs(actual - expected) > std::abs(epsilon))
    {
        Assert::FailInternal(String::Format(message, args...));
    }
}
 
template<class T>
inline void Assert::AreEqual(const T& expected, const T& actual)
{
    Assert::CheckInternal(expected == actual, String::Format(areEqualDefaultMessage, expected, actual));
}
 
template<class T, typename... Args>
inline void Assert::AreEqual(const T& expected, const T& actual, const char* message, const Args& ... args)
{
    Assert::CheckInternal(expected == actual, String::Format(message, args...));
}
 
// Assert::AreNotEqual() operations
inline void Assert::AreNotEqual(float expected, float actual, float epsilon)
{
    if (std::abs(actual - expected) <= std::abs(epsilon))
    {
        Assert::FailInternal(String::Format(areNotEqualDefaultMessage, expected, actual));
    }
}
 
inline void Assert::AreNotEqual(double expected, double actual, double epsilon)
{
    if (std::abs(actual - expected) <= std::abs(epsilon))
    {
        Assert::FailInternal(String::Format(areNotEqualDefaultMessage, expected, actual));
    }
}
 
template<typename... Args>
inline void Assert::AreNotEqual(float expected, float actual, float epsilon, const char* message, const Args& ... args)
{
    if (std::abs(actual - expected) <= std::abs(epsilon))
    {
        Assert::FailInternal(String::Format(message, args...));
    }
}
 
template<typename... Args>
inline void Assert::AreNotEqual(double expected, double actual, double epsilon, const char* message, const Args& ... args)
{
    if (std::abs(actual - expected) <= std::abs(epsilon))
    {
        Assert::FailInternal(String::Format(message, args...));
    }
}
 
template<class T>
inline void Assert::AreNotEqual(const T& expected, const T& actual)
{
    Assert::CheckInternal(expected != actual, String::Format(areNotEqualDefaultMessage, expected, actual));
}
 
template<class T, typename... Args>
inline void Assert::AreNotEqual(const T& expected, const T& actual, const char* message, const Args& ... args)
{
    Assert::CheckInternal(expected != actual, String::Format(message, args...));
}
 
// Assert::Fail() operations
template<typename... Args>
inline void Assert::Error(const char* message, const Args& ... args)
{
    Assert::ErrorInternal(String::Format(message, args...));
}
 
// Assert::Fail() operations
template<typename... Args>
inline void Assert::Fail(const char* message, const Args& ... args)
{
    Assert::FailInternal(String::Format(message, args...));
}
 
// IsTrue operations
template<class Predicate>
inline void Assert::IsTrue(Predicate predicate)
{
    Assert::CheckInternal(predicate ? true : false, isTrueDefaultMessage);
}
 
template<class Predicate, typename... Args>
inline void Assert::IsTrue(Predicate predicate, const char* message, const Args& ... args)
{
    Assert::CheckInternal(predicate ? true : false, String::Format(message, args...));
}
 
// IsFalse operations
template<class Predicate>
inline void Assert::IsFalse(Predicate predicate)
{
    Assert::CheckInternal(predicate ? false : true, isFalseDefaultMessage);
}
 
template<class Predicate, typename... Args>
inline void Assert::IsFalse(Predicate predicate, const char* message, const Args& ... args)
{
    Assert::CheckInternal(predicate ? false : true, String::Format(message, args...));
}
 
// IsNull operations
template<class T>
inline void Assert::IsNull(T* pValue)
{
    Assert::CheckInternal(pValue == nullptr, isNullDefaultMessage);
}
 
template<class T, typename... Args>
inline void Assert::IsNull(T* pValue, const char* message, const Args& ... args)
{
    Assert::CheckInternal(pValue == nullptr, String::Format(message, args...));
}
 
// IsNotNull operations
template<class T>
inline void Assert::IsNotNull(T* pValue)
{
    Assert::CheckInternal(pValue != nullptr, isNotNullDefaultMessage);
}
 
template<class T, typename... Args>
inline void Assert::IsNotNull(T* pValue, const char* message, const Args& ... args)
{
    Assert::CheckInternal(pValue != nullptr, String::Format(message, args...));
}
 
// IsEmpty operations
inline void Assert::IsEmpty(const String& s)
{
    Assert::CheckInternal(s.IsEmpty(), isEmptyDefaultMessage);
}
 
template<typename... Args>
inline void Assert::IsEmpty(const String& s, const char* message, const Args& ... args)
{
    Assert::CheckInternal(s.IsEmpty(), String::Format(message, args...));
}
 
// IsNotEmpty operations
inline void Assert::IsNotEmpty(const String& s)
{
    Assert::CheckInternal(!s.IsEmpty(), isNotEmptyDefaultMessage);
}
 
template<typename... Args>
inline void Assert::IsNotEmpty(const String& s, const char* message, const Args& ... args)
{
    Assert::CheckInternal(!s.IsEmpty(), String::Format(message, args...));
}
 
// Exists operations
inline void Assert::Exists(const String& path)
{
    Assert::CheckInternal(Io::File::Exists(path), existsDefaultMessage);
}
 
template<typename... Args>
inline void Assert::Exists(const String& path, const char* message, const Args& ... args)
{
    Assert::CheckInternal(Io::File::Exists(path), String::Format(message, args...));
}
 
// NotExists operations
inline void Assert::NotExists(const String& path)
{
    Assert::CheckInternal(!Io::File::Exists(path), notExistsDefaultMessage);
}
 
template<typename... Args>
inline void Assert::NotExists(const String& path, const char* message, const Args& ... args)
{
    Assert::CheckInternal(!Io::File::Exists(path), String::Format(message, args...));
}
 
// IsInstanceOf operations
template<class TExpected, class T>
inline void Assert::IsInstanceOfType(const T& instance)
{
    if (!Arp::IsInstanceOfType<TExpected>(instance))
    {
        Assert::FailInternal(String::Format(isInstanceOfTypeDefaultMessage, Arp::TypeName<TExpected>().Value));
    }
}
 
template<class TExpected, class T, typename... Args>
inline void Assert::IsInstanceOfType(const T& instance, const char* message, const Args& ... args)
{
    if (!Arp::IsInstanceOfType<TExpected>(instance))
    {
        Assert::FailInternal(String::Format(message, args...));
    }
}
 
template<class TExpected, class T>
inline void Assert::IsInstanceOfType(const T* pInstance)
{
    if (!Arp::IsInstanceOfType<TExpected>(pInstance))
    {
        Assert::FailInternal(String::Format(isInstanceOfTypeDefaultMessage, TypeName<TExpected>().Value));
    }
}
 
template<class TExpected, class T, typename... Args>
inline void Assert::IsInstanceOfType(const T* pInstance, const char* message, const Args& ... args)
{
    if (!Arp::IsInstanceOfType<TExpected>(pInstance))
    {
        Assert::FailInternal(String::Format(message, args...));
    }
}
 
// IsNotInstanceOf operations
template<class TExpected, class T>
inline void Assert::IsNotInstanceOfType(const T& instance)
{
    if (Arp::IsInstanceOfType<TExpected>(instance))
    {
        Assert::FailInternal(String::Format(isNotInstanceOfTypeDefaultMessage, TypeName<TExpected>().Value));
    }
}
 
template<class TExpected, class T, typename... Args>
inline void Assert::IsNotInstanceOfType(const T& instance, const char* message, const Args& ... args)
{
    if (Arp::IsInstanceOfType<TExpected>(instance))
    {
        Assert::FailInternal(String::Format(message, args...));
    }
}
 
template<class TExpected, class T>
inline void Assert::IsNotInstanceOfType(const T* pInstance)
{
    if (Arp::IsInstanceOfType<TExpected>(pInstance))
    {
        Assert::FailInternal(String::Format(isNotInstanceOfTypeDefaultMessage, TypeName<TExpected>().Value));
    }
}
 
template<class TExpected, class T, typename... Args>
inline void Assert::IsNotInstanceOfType(const T* pInstance, const char* message, const Args& ... args)
{
    if (IsInstanceOfType<TExpected>(pInstance))
    {
        Assert::FailInternal(String::Format(message, args...));
    }
}
 
// Throws operations
template<typename TException, typename TFunction>
inline void Assert::Throws(TFunction&& func)
{
    Assert::Throws<TException>(nullptr, std::forward<TFunction>(func));
}
 
#pragma warning (disable:4715)
 
template<typename TException, typename TFunction>
inline void Assert::Throws(const char* message, TFunction&& func)
{
    try
    {
        func();
    }
    catch (const TException&)
    {
        return; // success
    }
    catch (...)
    {
        // unexpected exception type was thrown
        if (message == nullptr)
        {
            Assert::FailInternal(throwsWrongTypeOfExceptionDefaultMessage);
        }
        else
        {
            Assert::FailInternal(message);
        }
    }
    // no exception at all
    if (message == nullptr)
    {
        Assert::FailInternal(String::Format(throwsNotDefaultMessage, TypeName<TException>().Value));
    }
    else
    {
        Assert::FailInternal(message);
    }
}
 
}}}} // end of namesapce Arp::System::Commons::Testing