unit_test.h

Go to the documentation of this file.

#ifndef META_UNIT_TEST_H_
#define META_UNIT_TEST_H_

#include <cmath>
#include <iomanip>
#include <string>
#include <functional>
#include <iostream>
#include "util/printing.h"

#define ASSERT(expr)                                                           \
    do                                                                         \
    {                                                                          \
        if (!(expr))                                                           \
            FAIL("Assertion failed: " #expr);                                  \
    } while (0)

#define ASSERT_EQUAL(exp1, exp2)                                               \
    do                                                                         \
    {                                                                          \
        std::string msg = testing::assert_equal(exp1, exp2, #exp1, #exp2);     \
        if (!msg.empty())                                                      \
            FAIL(msg);                                                         \
    } while (0)

#define ASSERT_APPROX_EQUAL(exp1, exp2)                                        \
    do                                                                         \
    {                                                                          \
        std::string msg                                                        \
            = testing::assert_approx_equal(exp1, exp2, #exp1, #exp2);          \
        if (!msg.empty())                                                      \
            FAIL(msg);                                                         \
    } while (0)

#define ASSERT_BINOP(exp1, exp2, binop)                                        \
    do                                                                         \
    {                                                                          \
        std::string msg = testing::assert(exp1, exp2, #exp1, #exp2, binop);    \
        if (!msg.empty())                                                      \
            FAIL(msg);                                                         \
    } while (0)

#define FAIL(why)                                                              \
    do                                                                         \
    {                                                                          \
        std::string fail_msg = "[ " + printing::make_red("FAIL") + " ] "       \
                               + (why) + " (" + testing::filename(__FILE__)    \
                               + ":" + std::to_string(__LINE__) + ")";         \
        throw testing::unit_test_exception{fail_msg};                          \
    } while (0)

#define ASSERT_LESS(exp1, exp2)                                                \
    do                                                                         \
    {                                                                          \
        std::string msg = testing::assert_less(exp1, exp2, #exp1, #exp2);      \
        if (!msg.empty())                                                      \
            FAIL(msg);                                                         \
    } while (0)

#define ASSERT_GREATER(exp1, exp2)                                             \
    do                                                                         \
    {                                                                          \
        std::string msg = testing::assert_greater(exp1, exp2, #exp1, #exp2);   \
        if (!msg.empty())                                                      \
            FAIL(msg);                                                         \
    } while (0)

namespace meta
{

namespace testing
{
static double epsilon = 0.0000001;

inline std::string filename(const std::string& path)
{
    size_t slash = path.find_last_of("/\\");
    if(slash == std::string::npos)
        return path;
    return path.substr(slash + 1);
}

template <class T, class K, class BinOp>
inline std::string assert_equal(const T& expected, const K& actual,
                                const char* expstr, const char* actstr,
                                BinOp&& binop)
{
    if (!binop(expected, actual))
    {
        std::stringstream ss;
        ss << "[" << expstr << " == " << actstr << "] => [" << expected
           << " == " << actual << "]";
        return ss.str();
    }
    return "";
}

template <class T, class K>
inline std::string assert_equal(const T& expected, const K& actual,
                                const char* expstr, const char* actstr)
{
    return assert_equal(expected, actual, expstr, actstr,
            [](const T& a, const K& b)
    {
        return a == b;
    });
}

template <class T, class K>
inline std::string assert_approx_equal(const T& expected, const K& actual,
                                       const char* expstr, const char* actstr)
{
    if (!(std::abs(expected - actual) < epsilon))
    {
        std::stringstream ss;
        ss << "[abs(" << expstr << " - " << actstr << ") < epsilon] => [abs("
           << expected << " - " << actual << ") < " << epsilon << "]";
        return ss.str();
    }
    return "";
}

template <class T, class K>
inline std::string assert_less(const T& expected, const K& actual,
                               const char* expstr, const char* actstr)
{
    if (!(expected < actual))
    {
        std::stringstream ss;
        ss << "[" << expstr << " < " << actstr << "] => [" << expected << " < "
           << actual << "]";
        return ss.str();
    }
    return "";
}

template <class T, class K>
inline std::string assert_greater(const T& expected, const K& actual,
                                  const char* expstr, const char* actstr)
{
    if (!(expected > actual))
    {
        std::stringstream ss;
        ss << "[" << expstr << " > " << actstr << "] => [" << expected << " > "
           << actual << "]";
        return ss.str();
    }
    return "";
}

class unit_test_exception: public std::runtime_error
{
    public:
        using std::runtime_error::runtime_error;
};

template <class Func>
int run_test(const std::string& test_name, Func&& func)
{
    try
    {
        func();
    }
    catch (std::exception& ex)
    {
        std::cerr << "        " << std::setw(40) << std::left
                  << (test_name + ": ") << ex.what() << std::endl;
        return 1;
    }

    return 0;
}
}
}

#endif