main.hh

#ifndef INCLUDED_T_MAIN_HH
#define INCLUDED_T_MAIN_HH

#ifndef TYPES_ARG_TRAITS_HH
#include "Types/arg_traits.hh"
#endif 

#include "SkippedException.hh"

extern int fatalmind_trace_malloc;
void dumpLeakedMemory();

#include <string>

#define assertTrue(x) _assertTrue(x, "assertTrue", __FILE__, __LINE__);
#define assertFalse(x) _assertTrue(!(x), "assertFalse", __FILE__, __LINE__);

#define assertNotPass() _assertNotPass(__FILE__, __LINE__)
#define assertNotReach() _assertNotPass(__FILE__, __LINE__)

#define assertEqual(i, e) _assertEqual((i), (e), __FILE__, __LINE__)
#define assertEqualT(t, i, e) _assertEqual<t>((i), (e), __FILE__, __LINE__)
#define assertNotEqual(i, e) _assertNotEqual<>((i), (e), __FILE__, __LINE__)
#define assertNotEqualT(t, i, e) _assertNotEqual<t>((i), (e), __FILE__, __LINE__)
#define assertLess(i, e) _assertLess<>((i), (e), __FILE__, __LINE__)
#define assertLessT(t, i, e) _assertLess<t>((i), (e), __FILE__, __LINE__)
#define assertNotLess(i, e) _assertNotLess<>((i), (e), __FILE__, __LINE__)
#define assertNotLessT(t, i, e) _assertNotLess<t>((i), (e), __FILE__, __LINE__)
#define assertMore(i, e) _assertMore<>((i), (e), __FILE__, __LINE__)
#define assertMoreT(t, i, e) _assertMore<t>((i), (e), __FILE__, __LINE__)
#define assertNotMore(i, e) _assertNotMore<>((i), (e), __FILE__, __LINE__)
#define assertNotMoreT(t, i, e) _assertNotMore<t>((i), (e), __FILE__, __LINE__)

#define assertNotGrowing(skipi) {static struct fatalmind_test_size sz; _assertNotGrown(sz, (skipi), __FILE__, __LINE__); }



template <typename T>
void _assertEqual(
      typename fatalmind::arg_traits<T>::const_param is
    , typename fatalmind::arg_traits<T>::const_param expect
    , const char* file
    , int line
);

/*
template <>
void _assertEqual<void*>(
      fatalmind::arg_traits<void*>::const_param is
    , fatalmind::arg_traits<void*>::const_param expect
    , const char* file
    , int line
);
*/

template<>
void _assertEqual<std::string>(
      fatalmind::arg_traits<std::string>::const_param is
    , fatalmind::arg_traits<std::string>::const_param expect
    , const char* file
    , int line
);

void _assertEqual(
      const int is
    , const int expect
    , const char* file
    , int line
);

void _assertEqual(
      const std::string& is
    , const std::string expect
    , const char* file
    , int line
);

//void _assertEqual(const std::string& is, const char* expect, const char* file, int line);

template <class T>
void _assertLess(T actual, T limit, const char* file, int line);

template <class T>
void _assertNotLess(T actual, T limit, const char* file, int line);

template <class T>
void _assertMore(T actual, T limit, const char* file, int line);

template <class T>
void _assertNotMore(T actual, T limit, const char* file, int line);

template <class T>
void _assertNotEqual(T is, T expect, const char* file, int line);

void _assertNotPass(const char* file, int line);
void _assertTrue(bool b, const char* s, const char* file, int line);

struct fatalmind_test_size {
        long    ru_idrss;
        int     icount;
};

void _assertNotGrown(fatalmind_test_size& sz, int skipiter, const char* file, int line);


class tester {
    public:
        tester(int, int);
        virtual ~tester() {
        }

        int run_tests();
        int run_allperf();
        virtual void init() = 0;
        virtual void cleanup() = 0;
        virtual void normal_test() = 0;
        virtual void run_perf() = 0;
        virtual void run_single_perf(int i) = 0;
        virtual const char* get_single_perf_name(int i) = 0;
        virtual int getSinglePerfTests() = 0;
        void test_it(void func(), const char *name);
        void printSummary();
        int getFAIL() {
            return FAIL;
        }
        int getSKIPPED() {
            return SKIPPED;
        }
        int getOK() {
            return OK;
        }
    private:
        int FAIL, num, OK, SKIPPED;
        int silent, loop;
};

#include "assert.cc"

#endif

---