testbench.h

Go to the documentation of this file.

 
#ifndef _TEST_BENCH_INCLUDES_
#define _TEST_BENCH_INCLUDES_
 
typedef void  tTestResult;  
 
struct tTestDoc
{
    const tChar* strId;              
    const tChar* strTitle;           
    const tChar* strShortDesc;       
    const tChar* strStrategy;        
    const tChar* strPassedIf;        
    const tChar* strRemarks;         
    const tChar* strFile;            
    tBool bActive;                  
    const tChar* strRequirements;    
    const tChar* strUser;            
};
 
struct tTestGroupDoc
{
    const tChar* strId;              
    const tChar* strTitle;           
    const tChar* strShortDesc;       
    const tChar* strRequirements;    
};
 
class DOEXPORT ITester
{
    public:
        virtual const tChar* getClassName()
        {
            return "unknown";
        }
 
        virtual void setUp()
        {
        }
 
        virtual void run()
        {
            setUp();
            tearDown();
        }
 
        virtual void tearDown()
        {
        }
 
        virtual tTestGroupDoc* getDoc()
        {
            return nullptr;
        }
};
 
class DOEXPORT ITestReportOutputter
{
    public:
        typedef enum
        {
            OF_Default          = 0x0,  
            OF_HidePassed       = 0x1,  
            OF_HideFailed       = 0x2,  
            OF_HideStatistics   = 0x4   
        } tOutputterFlags;
 
    public:
        virtual ~ITestReportOutputter() {}
 
        virtual void setFlags(tInt nFlags) = 0;
 
        virtual void beginReport() = 0;
 
        virtual void endReport() = 0;
 
        virtual void beginTester(ITester* pTester) = 0;
 
        virtual void endTester(ITester* pTester) = 0;
 
        virtual void writeTestFunction(tTestDoc* pDoc) = 0;
 
        virtual void writeTestFunctionEnd(tTestDoc* pDoc) = 0;
 
        virtual void writeResult(ITester* pTester,
                                 tBool bPassed,
                                 const tChar* strExpression,
                                 const tChar* strFile,
                                 tInt nLine,
                                 const tChar* strFunction,
                                 const tChar* strMessage) = 0;
};
 
class DOEXPORT ITestBench
{
    public:
        typedef enum
        {
            TEST_LOG_UNKNOWN = 0,   
            TEST_LOG_PASSED  = 1,   
            TEST_LOG_FAILED  = 2    
        } tLogType;
 
    public:
        virtual void* GetEnvironment() = 0;
 
        virtual tInt Initialize(tInt argc, const tChar* argv[]) = 0;
 
        virtual tInt RunTests() = 0;
 
        virtual tInt Shutdown() = 0;
 
        virtual void RegisterTester(ITester* pTester) = 0;
 
        virtual void LogTestFunction(const tChar* strFunction) = 0;
 
        virtual void Log(tInt nLogType,
                         const tChar* strText,
                         const tChar* strExpression,
                         const tChar* strFile,
                         tInt nLine,
                         const tChar* strFunction = nullptr,
                         const tChar* strMessage = nullptr) = 0;
 
        virtual void LogStartFunction(tTestDoc* pDoc) = 0;
 
        virtual void LogStopFunction(tTestDoc* pDoc) = 0;
 
        virtual void RegisterOutputter(ITestReportOutputter* pOutputter) = 0;
 
        virtual tBool IsOK() = 0;
 
        virtual tResult GetPluginDirs(A_UTILS_NS::cStringList& lstDirs) = 0;
 
        virtual A_UTILS_NS::cFilename GetOutputDir() = 0;
 
        virtual A_UTILS_NS::cFilename GetWorkingDir() = 0;
};
 
ITestBench* __get_testbench();
 
extern tInt RunTestBench(tInt argc=0,
                        const tChar* argv[]=nullptr,
                        ITestReportOutputter* pConsoleOutputter=nullptr,
                        tInt nConsoleOutputterFlags=0,
                        ITestReportOutputter* pFileOutputter=nullptr,
                        tInt nFileOutputterFlags=0);
 
tVoid OutputDebugStringWrapper(const tChar* strMessage);
 
#endif // _TEST_BENCH_INCLUDES_