testmacros.h

Go to the documentation of this file.

 
#ifndef _TEST_MACROS_INCLUDES_
#define _TEST_MACROS_INCLUDES_
 
namespace A_UTILS_NS
{
#ifdef _ASSERT_BASE
    #define __a_utils_local_assert_fn(_expr, _msg) \
        (void) ((!!(_expr)) || \
                (1 != _CrtDbgReport(_CRT_ASSERT, __FILE__, __LINE__, nullptr, A_UTILS_NS::cString(_msg).GetPtr())) || \
                (_CrtDbgBreak(), 0));
 
    #define __a_utils_test_assert(_msg, _expr) \
        __a_utils_local_assert_fn((_expr), A_UTILS_NS::cString(_msg).GetPtr())
 
    #define __a_utils_test_report(_msg) \
        __a_utils_local_assert_fn(false, A_UTILS_NS::cString(_msg).GetPtr())
 
    #define __a_utils_test_log(_msg) \
        printf("%s(%d) %s %s\n", __FILE__, __LINE__, __FUNCTION__, A_UTILS_NS::cString(_msg).GetPtr()); \
        OutputDebugStringWrapper(_msg)
#else
    #define __a_utils_test_assert(_msg, _expr) \
        _assert((_expr), __FILE__, __LINE__)
 
    #define __a_utils_test_report(_msg) \
        _assert(false, __FILE__, __LINE__)
 
    #define __a_utils_test_log(_msg) \
        printf("%s(%d) %s\n", __FILE__, __LINE__, A_UTILS_NS::cString(_msg).GetPtr())
#endif
 
#if (defined(ENABLE_INTERACTIVE_TEST) && defined(_DEBUG))
 
    #define __a_utils_interactive_test(_expr) \
        if (!(_expr)) \
        { \
            __a_utils_test_report("test failed: (" #_expr ")"); \
            RETURN_TEST_ERROR(ERR_FAILED); \
        } \
        else \
        { \
            __a_utils_test_pass(_expr); \
        }
 
    #define __a_utils_interactive_test_err(_expr) \
        if ((_expr)) \
        { \
            __a_utils_test_report("bad case test failed: (" #_expr ")"); \
            RETURN_TEST_ERROR(ERR_FAILED); \
        } \
        else \
        { \
            __a_utils_test_pass(_expr); \
        }
 
    #define __a_utils_interactive_test_result(_expr) \
        { \
            tResult __result = (_expr); \
            if (IS_FAILED(__result)) \
            { \
                __a_utils_test_report("test failed: (" #_expr " == OK)"); \
                RETURN_TEST_ERROR(__result); \
            } \
            else \
            { \
                __a_utils_test_pass_result(_expr); \
            } \
        }
 
    #define __a_utils_interactive_test_err_result(_expr) \
        { \
            tResult __result = (_expr); \
            if (IS_OK(__result)) \
            { \
                __a_utils_test_report("bad case test failed: (" #_expr " == OK)"); \
                RETURN_TEST_ERROR(__result); \
            } \
            else \
            { \
                __a_utils_test_pass_result(_expr); \
            } \
        }
 
    #define __a_utils_interactive_test_pointer(_ptr) \
        if ((void*)(_ptr) == nullptr) \
        { \
            __a_utils_test_report("test failed: (" #_ptr " != nullptr)"); \
            RETURN_TEST_ERROR(_errcode_POINTER); \
        } \
        else \
        { \
            __a_utils_test_pass_pointer(_ptr); \
        }
 
    #define __a_utils_interactive_test_pointer_null(_ptr) \
        if ((void*)(_ptr) != nullptr) \
        { \
            __a_utils_test_report("bad case test failed: (" #_ptr " != nullptr)"); \
            RETURN_TEST_ERROR(_errcode_POINTER); \
        } \
        else \
        { \
            __a_utils_test_pass_pointer(_ptr); \
        }
 
    #define __a_utils_test_pass(_expr)
 
    #define __a_utils_test_pass_result(_expr)
 
    #define __a_utils_test_pass_pointer(_ptr)
 
    #define __a_utils_test(_expr) \
        __a_utils_interactive_test(_expr)
 
    #define __a_utils_test_err(_expr) \
        __a_utils_interactive_test_err(_expr)
 
    #define __a_utils_test_result(_expr) \
        __a_utils_interactive_test_result(_expr)
 
    #define __a_utils_test_err_result(_expr) \
        __a_utils_interactive_test_err_result(_expr)
 
    #define __a_utils_test_err_result_code(_expected, _expr) \
        __a_utils_log_test("test failed: (" #_expr " == OK)", (_expr) == (_expected))
 
    #define __a_utils_test_pointer(_ptr) \
        __a_utils_interactive_test_pointer(_ptr)
 
    #define __a_utils_test_pointer_null(_ptr) \
        __a_utils_interactive_test_pointer_null(_ptr)
 
#else // ENABLE_INTERACTIVE_TEST
 
    #define __a_utils_log_test_fail(_msg, _expr, _umsg) \
        { \
            __get_testbench()->Log(ITestBench::TEST_LOG_FAILED, _msg, #_expr, __FILE__, __LINE__, __FUNCTION__, _umsg); \
            throw "test failed"; \
        }
 
    #define __a_utils_log_test_succ(_msg, _expr, _umsg) \
        { \
            __get_testbench()->Log(ITestBench::TEST_LOG_PASSED, _msg, #_expr, __FILE__, __LINE__, __FUNCTION__, _umsg); \
        }
        
    #define __a_utils_log_test(_msg, _expr) \
        if (!(_expr)) \
        { \
            __a_utils_log_test_fail(_msg, _expr, nullptr) \
        } \
        else \
        { \
            __a_utils_log_test_succ(_msg, _expr, nullptr) \
        }
 
    #define __a_utils_log_test_ext(_msg, _expr, _umsg) \
        if (!(_expr)) \
        { \
            __a_utils_log_test_fail(_msg, _expr, _umsg) \
        } \
        else \
        { \
            __a_utils_log_test_succ(_msg, _expr, _umsg) \
        }
 
    #define __a_utils_test(_expr) \
        __a_utils_log_test("test failed: (" #_expr ")", (_expr))
 
    #define __a_utils_test_err(_expr) \
        __a_utils_log_test("bad case test failed: (" #_expr ")", (!(_expr)))
 
    #define __a_utils_test_result(_expr) \
    {\
        tResult __nHelperResult = _expr; \
        if (IS_FAILED(__nHelperResult)) \
        {\
            __a_utils_test_log(A_UTILS_NS::cString::Format(#_expr " returned error code: %d  (description: %s)", __nHelperResult.GetErrorCode().value, __nHelperResult.GetDescription()));\
            __a_utils_log_test_fail("test failed: IS_OK(" #_expr ")", IS_OK(_expr), nullptr);\
        }\
        else \
        { \
            __a_utils_log_test_succ("test failed: IS_OK(" #_expr ")", IS_OK(_expr), nullptr);\
        } \
    }
 
    #define __a_utils_test_err_result(_expr) \
        __a_utils_log_test("bad case test failed: IS_FAILED(" #_expr ")", (IS_FAILED(_expr)))
 
    #define __a_utils_test_pointer(_ptr) \
        __a_utils_log_test("test failed: (" #_ptr " != nullptr)", ((_ptr)!=nullptr))
 
    #define __a_utils_test_pointer_null(_ptr) \
        __a_utils_log_test("bad case test failed: (" #_ptr " != nullptr)", ((_ptr)==nullptr))
 
    #define __a_utils_test_ext(_expr, _msg) \
        __a_utils_log_test_ext("test failed: (" #_expr ")", (_expr), (_msg))
 
    #define __a_utils_test_err_ext(_expr, _msg) \
        __a_utils_log_test_ext("bad case test failed: (" #_expr ")", (!(_expr)), (_msg))
 
    #define __a_utils_test_result_ext(_expr, _msg)\
    {\
        tResult __nHelperResult = _expr; \
        if (IS_FAILED(__nHelperResult)) \
        {\
            __a_utils_test_log(A_UTILS_NS::cString::Format(#_expr " returned error code: %d", __nHelperResult.GetErrorCode()));\
            __a_utils_log_test_fail("test failed: IS_OK(" #_expr ")", IS_OK(_expr), (_msg));\
        }\
        else \
        { \
            __a_utils_log_test_succ("test failed: IS_OK(" #_expr ")", IS_OK(_expr), (_msg));\
        } \
    }
 
    #define __a_utils_test_err_result_ext(_expr, _msg) \
        __a_utils_log_test_ext("bad case test failed: IS_FAILED(" #_expr ")", (IS_FAILED(_expr)), (_msg))
 
    #define __a_utils_test_pointer_ext(_ptr, _msg) \
        __a_utils_log_test_ext("test failed: (" #_ptr " != nullptr)", ((_ptr)!=nullptr), (_msg))
 
    #define __a_utils_test_pointer_null_ext(_ptr, _msg) \
        __a_utils_log_test_ext("bad case test failed: (" #_ptr " != nullptr)", ((_ptr)==nullptr), (_msg))
 
    #define __a_utils_test_file_exists(_filename)\
        __a_utils_test_ext(A_UTILS_NS::cFileSystem::Exists(_filename), _filename + A_UTILS_NS::cString(" does not exist"));
 
 
#endif // ENABLE_INTERACTIVE_TEST
 
// ENABLE WHITEBOX TESTS
 
#define DECLARE_TESTER_FRIEND(_tester, _whitebox) \
  class _testable_##_whitebox : public _whitebox \
  { friend class _tester; };
 
#define __a_utils_test_friend(_whitebox) _testable_##_whitebox
 
// IMPLEMENTATION SUPPORT MACROS
 
#define RETURN_TEST_NOERROR
 
#define RETURN_TEST_ERROR(_code)
 
#define DECLARE_TESTER_CLASS(_classname) \
    class _classname : public ITester
 
#define BEGIN_TESTER_MAP(_classname) \
  public: \
  _classname(); \
  const char* getClassName(); \
  virtual void run() {
 
#define DECLARE_TESTER_FUNCTION(_func) \
    extern tTestDoc sFunctionDoc_##_func; \
    __get_testbench()->LogStartFunction(&sFunctionDoc_##_func); \
    if (sFunctionDoc_##_func.bActive) \
    { \
        try \
        { \
            setUp(); \
            _func(); \
        } \
        catch (const char*) { } \
        try \
        { \
            tearDown(); \
        } \
        catch (const char*) { } \
    } \
    __get_testbench()->LogStopFunction(&sFunctionDoc_##_func); \
    
 
#define END_TESTER_MAP() \
    } \
    tTestGroupDoc* getDoc();
 
#define DECLARE_TESTER_CLASS(_classname) \
    class _classname : public ITester
 
#define IMPLEMENT_TESTER_CLASS(_classname, _id, _title, _desc, _req) \
    static _classname _instance_##_classname; \
    _classname::_classname() \
    { __get_testbench()->RegisterTester(this); } \
    const char* _classname::getClassName() \
    { return #_classname; } \
    tTestGroupDoc* _classname::getDoc() \
    { \
        static tTestGroupDoc sDoc= { _id, _title, _desc, _req }; \
        return &sDoc; \
    }
 
// For internal use only 
#define IMPLEMENT_TESTER_CLASS_CLASSNAME(_classname, _id, _title, _desc, _req) \
    static _classname _instance_##_classname; \
    _classname::_classname() \
    { __get_testbench()->RegisterTester(this); } \
    const char* _classname::getClassName() \
    { return #_classname; } \
    tTestGroupDoc* _classname::getDoc() \
    { \
        static tTestGroupDoc sDoc= { _id, #_classname, _desc, _req }; \
        return &sDoc; \
    }
 
#define DEFINE_TEST(_classname, _func, _id, _title, _desc, _strat, _passedif, _remarks, _req, _user) \
    tTestDoc sFunctionDoc_##_func = { _id, _title, _desc, _strat, _passedif, _remarks, __FILE__, tTrue, _req, _user }; \
    tTestResult _classname::_func()
 
// For internal use only 
#define DEFINE_TEST_FUNCNAME(_classname, _func, _id, _title, _desc, _strat, _passedif, _remarks, _req, _user) \
    tTestDoc sFunctionDoc_##_func = { _id, #_classname "::" #_func, _desc, _strat, _passedif, _remarks, __FILE__, tTrue, _req, _user }; \
    tTestResult _classname::_func()
 
#define DEFINE_TEST_INACTIVE(_classname, _func, _id, _title, _desc, _strat, _passedif, _remarks, _req, _user) \
    tTestDoc sFunctionDoc_##_func = { _id, _title, _desc, _strat, _passedif, _remarks, __FILE__, tFalse, _req, _user }; \
    tTestResult _classname::_func()
 
// For internal use only  
#define DEFINE_TEST_INACTIVE_FUNCNAME(_classname, _func, _id, _title, _desc, _strat, _passedif, _remarks, _req, _user) \
    tTestDoc sFunctionDoc_##_func = { _id, #_classname "::" #_func "_INACTIVE", _desc, _strat, _passedif, _remarks, __FILE__, tFalse, _req, _user }; \
    tTestResult _classname::_func()
 
#ifdef A_UTILS_TESTER_USE_CLASS_AND_FUNC_NAMES
    #undef IMPLEMENT_TESTER_CLASS
    #undef DEFINE_TEST
    #undef DEFINE_TEST_INACTIVE
    
    #define IMPLEMENT_TESTER_CLASS(_classname, _id, _title, _desc, _req) \
        IMPLEMENT_TESTER_CLASS_CLASSNAME(_classname, _id, _title, _desc, _req)
    #define DEFINE_TEST(_classname, _func, _id, _title, _desc, _strat, _passedif, _remarks, _req, _user) \
        DEFINE_TEST_FUNCNAME(_classname, _func, _id, _title, _desc, _strat, _passedif, _remarks, _req, _user)
    #define DEFINE_TEST_INACTIVE(_classname, _func, _id, _title, _desc, _strat, _passedif, _remarks, _req, _user) \
        DEFINE_TEST_INACTIVE_FUNCNAME(_classname, _func, _id, _title, _desc, _strat, _passedif, _remarks, _req, _user)
#endif
 
} // namespace
 
#endif // _TEST_MACROS_INCLUDES_