test_runner.h

#include <sstream>
#include <exception>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>

//================================================================================================
// Output operators for: vector, set, map, unordered_map

template <class T>
std::ostream& operator << ( std::ostream& os, const std::set<T>& s )
{
    os << "{";
    bool first = true;
    for ( const auto& x : s ) {
        if ( !first ) {
            os << ", ";
        }
        first = false;
        os << x;
    }
    return os << "}";
}

template <class T>
std::ostream& operator << (std::ostream& os, const std::vector<T>& s )
{
    os << "[";
    bool first = true;
    for ( const auto& x : s ) {
        if ( !first ) {
            os << ", ";
        }
        first = false;
        os << x;
    }
    return os << "]";
}

template <class K, class V>
std::ostream& operator << (std::ostream& os, const std::map<K, V>& m )
{
    os << "{";
    bool first = true;
    for ( const auto& kv : m ) {
        if ( !first ) {
            os << ", ";
        }
        first = false;
        os << kv.first << ": " << kv.second;
    }
    return os << "}";
}

template <class K, class V>
std::ostream& operator << (std::ostream& os, const std::unordered_map<K, V>& m )
{
    os << "{";
    bool first = true;
    bool first_another = true;
    for ( const auto& kv : m ) {
        if ( !first ) {
            os << " | ";
        }
        first = false;
        os << kv.first << ": ";
        for ( const auto& el : kv.second ) {
            if ( !first_another ) {
                os << ", ";
            }
            os << el;
        }
    }
    return os << "}";
}

//================================================================================================
// Custom asserts ensuring equality/truth

template <class T, class U>
void AssertEqual( const T& t, const U& u, const std::string& hint = {} )
{
    if ( !(t == u) ) {
        std::ostringstream os;
        os << "Assertion failed: " << t << " != " << u;
        if ( !hint.empty() ) {
            os << " hint: " << hint;
        }
        throw std::runtime_error( os.str() );
    }
}

inline void Assert( bool b, const std::string& hint )
{
    AssertEqual( b, true, hint );
}

//================================================================================================
// Class to run individual tests and will terminate the program if any of them fail

class TestRunner {
public:
    template <class TestFunc>
    void RunTest( TestFunc func, const std::string& test_name )
    {
        try {
            func();
            std::cerr << test_name << " OK" << std::endl;
        }
        catch (std::runtime_error& e ) {
            ++fail_count;
            std::cerr << test_name << " fail: " << e.what() << std::endl;
        }
    }

    ~TestRunner()
    {
        if ( fail_count > 0 ) {
            std::cerr << fail_count << " unit tests failed. Terminate" << std::endl;
            exit( 1 );
        }
    }

private:
    int fail_count = 0;
};

//================================================================================================
// Quality of life macros

#define ASSERT_EQUAL(x, y) {                               \
  std::ostringstream __assert_equal_private_os;            \
  __assert_equal_private_os << #x << " != " << #y << ", "  \
    << __FILE__ << ":" << __LINE__;                        \
  AssertEqual(x, y, __assert_equal_private_os.str());      \
}

#define ASSERT(x) {                  \
  std::ostringstream os;             \
  os << #x << " is false, "          \
    << __FILE__ << ":" << __LINE__;  \
  Assert(x, os.str());               \
}

#define RUN_TEST(tr, func)  \
  tr.RunTest(func, #func)