test.h

Go to the documentation of this file.

#pragma once

#include <QObject>
#include <QString>
#include <QSharedPointer>
#include <QTextStream>


//=============================================================================
// MACROS
//=============================================================================

#define TEST_CONCATENATE_DETAIL(x, y) x##y
#define TEST_CONCATENATE(x, y) TEST_CONCATENATE_DETAIL(x, y)
#define TEST_MAKE_UNIQUE(x) TEST_CONCATENATE(x, __COUNTER__)

#define DECLARE_TEST(className) static edbee::test::Test<className> TEST_MAKE_UNIQUE(t)(#className)
#define DECLARE_NAMED_TEST(name,className) static edbee::test::Test<className> TEST_MAKE_UNIQUE(name)(#className)


namespace edbee { namespace test {


class OutputHandler;
class TestEngine;
class TestCase;

//=============================================================================
// Test Results
//=============================================================================

template <class T>
QString toQString( const T& obj )
{
    return QString("%1").arg(obj);
}


class TestResult
{
public:
    enum Status {
        Passed, Failed, Skipped
    };

    explicit TestResult( TestCase* testCase, const QString& methodName, const QString& description, const char* file, int lineNumber );
    virtual ~TestResult() {}

    virtual void setBooleanResult( bool result, const char *statement  );
    //virtual void setCompareResult( const QString& actualValue, const QString& expectedValue, const char* actualStatement, const char* expectedStatement );

    virtual void setCompareResult( bool result, const QString& actualValue, const QString& expectedValue, const char* actualStatement, const char* expectedStatement );

//    template <class T>
//    void setCompareResult( const T& actualValue, const T& expectedValue, const char* actualStatement, const char* expectedStatement )
//    {
//        setCompareResult( actualValue == expectedValue, toQString(actualValue), toQString(expectedValue), actualStatement, expectedStatement );
//    }

    virtual void setSkip();

    virtual TestCase* testCae() { return testCaseRef_; }
    virtual QString methodName() { return methodName_; }
    virtual QString description() { return description_; }
    virtual const char* fileName() { return fileNameRef_; }
    virtual int lineNumber() { return lineNumber_; }

    virtual bool compareStatement() { return compareStatement_; }
    virtual const char* actualStatement() { return actualStatementRef_; }
    virtual const char* statement() { return actualStatementRef_; }
    virtual const char* expectedStatement() { return expectedStatementRef_; }
    virtual QString actualValue() { return actualValue_; }
    virtual QString expectedValue() { return expectedValue_; }

    virtual Status status() { return status_; }


private:

    // method / line defionition
    TestCase* testCaseRef_;         
    QString  methodName_;           
    QString description_;           
    const char* fileNameRef_;       
    int lineNumber_;                

    // code definition
    bool compareStatement_;            
    const char* actualStatementRef_;   
    const char* expectedStatementRef_; 
    QString actualValue_;              
    QString expectedValue_;            

    // the result
    Status status_;                    
};




//=============================================================================
// Test Unit Class
//=============================================================================

#define GET_3TH_ARG(arg1, arg2, arg3, ...) arg3
#define GET_4TH_ARG(arg1, arg2, arg3, arg4, ...) arg4


#define testTrue_1(statement)                testTrueImpl( ( statement ) ? true : false, #statement, "", __FILE__, __LINE__)
#define testTrue_2(statement, message)       testTrueImpl( ( statement ) ? true : false, #statement, (message), __FILE__, __LINE__ )
#define testTrue_MACRO_CHOOSER(...) \
    GET_3TH_ARG(__VA_ARGS__, testTrue_2, testTrue_1, )
#define testTrue(...) testTrue_MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)


#define testFalse(statement)    testTrue( !statement )


#define testEqual_1(actual,expected) do { \
    QString actualStr = edbee::test::toQString(actual); \
    QString expectedStr = edbee::test::toQString(expected); \
    testEqualImpl( ( actualStr ) == ( expectedStr ), actualStr, expectedStr, #actual, #expected, "", __FILE__, __LINE__ ); \
} while( false )

#define testEqual_2(actual,expected, message) do \
    QString actualStr = edbee::test::toQString(actual); \
    QString expectedStr = edbee::test::toQString(expected); \
    testEqualImpl( ( actualStr ) == ( expectedStr ), actualStr, expectedStr, #actual, #expected, (message), __FILE__, __LINE__ ); \
} while( false )


#define testEqual_MACRO_CHOOSER(...) \
    GET_4TH_ARG(__VA_ARGS__, testEqual_2, testEqual_1, )
#define testEqual(...) testEqual_MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)


#define testSkip(msg) testSkipImpl( msg, __FILE__, __LINE__)






class TestCase : public QObject
{
    Q_OBJECT
public:
    explicit TestCase();

    virtual TestEngine* engine() { return engineRef_; }
    virtual void setEngine( TestEngine *engine ) { engineRef_ = engine; }

    virtual OutputHandler* out();


    virtual void testTrueImpl( bool condition, const char* statement, const QString& description, const char* file, int line );


    virtual void testEqualImpl( bool result, const QString& actual, const QString& expected,
                                    const char* actualStatement, const char* expectedStatement,
                                    const QString& description, const char* file, int line );

    virtual void testSkipImpl( const QString& description, const char* file, int line );


    virtual TestCase* currentTest(); // usually returns this :P
    virtual QString currentMethodName();
    virtual void giveTestResultToEngine( TestResult* result );


signals:

public slots:

private slots:

private:

    TestEngine *engineRef_;       
};


//=============================================================================
// Output Handling
//=============================================================================

class OutputHandler
{
public:

    explicit OutputHandler();
    virtual ~OutputHandler();

    // writes down the start of a multiple test run
    virtual void startTestRun( TestEngine* engine );
    virtual void endTestRun( TestEngine* engine );


    // writes down the 'category' of the test
    virtual void startTestCase( TestEngine* engine );
    virtual void endTestCase( TestEngine* engine );


    // method output of the test case
    virtual void startTestMethod( TestEngine* engine );
    virtual void endTestMethod( TestEngine* engine );

    virtual void testResultAdded( TestEngine* engine, TestResult* testResult );



private:

    QString buffer_;
    QString failBuffer_;
    QString outBuffer_;

    // this method notifies that a value is wrong
//    void writeSuccess( TestCase & testCase, const char *methodName );

    // fails with the given messages
    //void fail( const QString & message, const QString & details = ""  ) ;
};




//=============================================================================
// Test Engine
//=============================================================================

class TestEngine : public QObject
{
    Q_OBJECT
public:

    explicit TestEngine();
    virtual ~TestEngine();

    virtual bool hasTest(TestCase* object);
    virtual void addTest(TestCase* object);
    virtual int runAll();
    virtual int run( TestCase* object );
    virtual int run( const QString& name );
    virtual void startRun();
    virtual void endRun();

    virtual OutputHandler* outputHandler() { return outputHandlerRef_; }
    virtual void setOutputHandler( OutputHandler* handler ) { outputHandlerRef_ = handler; }

    virtual TestCase* currentTest() { return currentTestRef_; }

    virtual const char* currentClassName() { return currentTestRef_->metaObject()->className(); }

    virtual QString currentMethodName() { return currentMethodName_; }

    virtual void giveTestResult( TestResult* testResult );

    virtual QList<TestResult*> testResultList() { return testResultList_; }

private:

    QList<TestCase*> testRefList_;     
    OutputHandler* outputHandlerRef_;  

    // the current state
    TestCase* currentTestRef_;           
    QString currentMethodName_;          
//    const char* currentMethodNameRef_;  ///< A reference to the current method

    // test results
    QList<TestResult*> testResultList_;  
};


//=============================================================================
// Appending Tests via a Macro
//=============================================================================

// this method returns the test engine
inline TestEngine& engine()
{
    static TestEngine engine;
    return engine;
}


template <class T>
class Test
{
public:
    QSharedPointer<T> child;

    Test(const QString& name) : child(new T)
    {
        child->setObjectName(name);
        engine().addTest(child.data());
    }
};


}} // edbee::test