tut_result.hpp

#ifndef TUT_RESULT_H_GUARD
#define TUT_RESULT_H_GUARD
#include <tut/tut_config.hpp>

#include <string>

#if defined(TUT_USE_RTTI)
#if (defined(_MSC_VER) && !defined(_CPPRTTI)) || (defined(__GNUC__) && !defined(__GXX_RTTI))
#undef TUT_USE_RTTI
#endif
#endif

#if defined(TUT_USE_RTTI)
#include <typeinfo>
#endif

namespace tut
{

#if defined(TUT_USE_RTTI)
template<typename T>
inline std::string type_name(const T& t)
{
    return typeid(t).name();
}
#else
template<typename T>
inline std::string type_name(const T& t)
{
    return "Unknown type, RTTI disabled";
}

inline std::string type_name(const std::exception&)
{
    return "Unknown std::exception, RTTI disabled";
}
#endif


#if defined(TUT_USE_POSIX)
struct test_result_posix
{
    test_result_posix()
        : pid(getpid())
    {
    }

    virtual ~test_result_posix()
    {
    }

    pid_t pid;
};
#else
struct test_result_posix
{
    virtual ~test_result_posix()
    {
    }
};
#endif

struct test_result : public test_result_posix
{
    std::string group;

    int test;

    std::string name;

    enum result_type
    {
        ok,       
        fail,     
        ex,       
        warn,     
        term,     
        ex_ctor,  
        rethrown, 
        skipped,  
        dummy     
    };

    result_type result;

    std::string message;
    std::string exception_typeid;

    test_result()
        : group(),
          test(0),
          name(),
          result(ok),
          message(),
          exception_typeid()
    {
    }

    test_result(const std::string& grp, int pos,
                const std::string& test_name, result_type res)
        : group(grp),
          test(pos),
          name(test_name),
          result(res),
          message(),
          exception_typeid()
    {
    }

    test_result(const std::string& grp,int pos,
                const std::string& test_name, result_type res,
                const std::exception& ex)
        : group(grp),
          test(pos),
          name(test_name),
          result(res),
          message(ex.what()),
          exception_typeid(type_name(ex))
    {
    }

    test_result(const std::string& grp,int pos,
                const std::string& test_name, result_type res,
                const std::string& ex_typeid,
                const std::string& msg)
        : group(grp),
          test(pos),
          name(test_name),
          result(res),
          message(msg),
          exception_typeid(ex_typeid)
    {
    }

    virtual ~test_result()
    {
    }
};

}

#endif