tester.h

Go to the documentation of this file.

/*
 * tester.h
 *
 * Copyright (C)  2004  Zack Rusin <zack@kde.org>
 * Copyright (C)  2005  Jeroen Wijnhout <Jeroen.Wijnhout@kdemail.net>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef TESTER_H
#define TESTER_H
 
#include <iostream>
using namespace std;
 
#include <tqobject.h>
#include <tqstringlist.h>
#include <tqasciidict.h>
 
#include <tdelibs_export.h>
 
#define CHECK( x, y ) check( __FILE__, __LINE__, #x, x, y, false )
 
#define COMPARE CHECK
 
#define VERIFY( x ) CHECK( x, true )
 
#define XFAIL( x, y ) check( __FILE__, __LINE__, #x, x, y, true )
 
#define SKIP( x ) skip( __FILE__, __LINE__, TQString::fromLatin1(#x))
 
#define CHECK_EXCEPTION(exceptionCatch, expression) \
    try \
    { \
        expression; \
    } \
    catch(exceptionCatch) \
    { \
        setExceptionRaised(true); \
    } \
    if(exceptionRaised()) \
    { \
        success(TQString(__FILE__) + "[" + TQString::number(__LINE__) + "]: passed " + #expression); \
    } \
    else \
    { \
        failure(TQString(__FILE__) + "[" + TQString::number(__LINE__) + TQString("]: failed to throw " \
                "an exception on: ") + #expression); \
    } \
    setExceptionRaised(false);
 
#define XFAIL_EXCEPTION(exceptionCatch, expression) \
    try \
    { \
        expression; \
    } \
    catch(exceptionCatch) \
    { \
        setExceptionRaised(true); \
    } \
    if(exceptionRaised()) \
    { \
        unexpectedSuccess(TQString(__FILE__) + "[" + TQString::number(__LINE__) + "]: unexpectedly threw an exception and passed: " + #expression); \
    }\
    else \
    { \
        expectedFailure(TQString(__FILE__) + "[" + TQString::number(__LINE__) + TQString("]: failed to throw an exception on: ") + #expression); \
    } \
    setExceptionRaised(false);
 
#define SKIP_EXCEPTION(exceptionCatch, expression) \
    skip( __FILE__, __LINE__, TQString("Exception catch: ")\
            .arg(TQString(#exceptionCatch)).arg(TQString(" Test expression: ")).arg(TQString(#expression)))
 
namespace KUnitTest
{
    class TDEUNITTEST_EXPORT TestResults
    {
        friend class Tester;
 
    public:
        TestResults() : m_tests( 0 ) {}
 
        virtual ~TestResults() {}
 
        virtual void clear()
        {
            m_errorList.clear();
            m_xfailList.clear();
            m_xpassList.clear();
            m_skipList.clear();
            m_successList.clear();
            m_debug = "";
            m_tests = 0;
        }
 
        virtual void addDebugInfo(const TQString &debug)
        {
            m_debug += debug;
        }
 
        TQString debugInfo() const { return m_debug; }
 
        int testsFinished() const { return m_tests; }
 
        int errors() const { return m_errorList.count(); }
 
        int xfails() const { return m_xfailList.count(); }
 
        int xpasses() const { return m_xpassList.count(); }
 
        int skipped() const { return m_skipList.count(); }
 
        int passed() const { return m_successList.count(); }
 
        TQStringList errorList() const { return m_errorList; }
 
        TQStringList xfailList() const { return m_xfailList; }
 
        TQStringList xpassList() const { return m_xpassList; }
 
        TQStringList skipList() const { return m_skipList; }
 
        TQStringList successList() const { return m_successList; }
 
    private:
        TQStringList m_errorList;
        TQStringList m_xfailList;
        TQStringList m_xpassList;
        TQStringList m_skipList;
        TQStringList m_successList;
        TQString     m_debug;
        int         m_tests;
    };
 
    typedef TQAsciiDict<TestResults> TestResultsListType;
 
    typedef TQAsciiDictIterator<TestResults> TestResultsListIteratorType;
 
    class TDEUNITTEST_EXPORT Tester : public TQObject
    {
    public:
        Tester(const char *name = 0L)
        : TQObject(0L, name), m_results(new TestResults()), m_exceptionState(false)
        {}
 
        virtual ~Tester() { delete m_results; }
 
    public:
        virtual void allTests() = 0;
 
    public:
        virtual TestResults *results() { return m_results; }
 
    protected:
        void skip( const char *file, int line, TQString msg )
        {
            TQString skipEntry;
            TQTextStream ts( &skipEntry, IO_WriteOnly );
            ts << file << "["<< line <<"]: " << msg;
            skipTest( skipEntry );
        }
 
        template<typename T>
        void check( const char *file, int line, const char *str,
                    const T  &result, const T &expectedResult,
                    bool expectedFail )
        {
            cout << "check: " << file << "["<< line <<"]" << endl;
 
            if ( result != expectedResult )
            {
                TQString error;
                TQTextStream ts( &error, IO_WriteOnly );
                ts << file << "["<< line <<"]: failed on \"" <<  str
                   <<"\" result = '" << result << "' expected = '" << expectedResult << "'";
 
                if ( expectedFail )
                    expectedFailure( error );
                else
                    failure( error );
 
            }
            else
            {
                // then the test passed, but we want to record it if
                // we were expecting a failure
                if (expectedFail)
                {
                    TQString err;
                    TQTextStream ts( &err, IO_WriteOnly );
                    ts << file << "["<< line <<"]: "
                       <<" unexpectedly passed on \""
                       <<  str <<"\"";
                    unexpectedSuccess( err );
                }
                else
                {
                    TQString succ;
                    TQTextStream ts( &succ, IO_WriteOnly );
                    ts << file << "["<< line <<"]: "
                       <<" passed \""
                       <<  str <<"\"";
                    success( succ );
                }
            }
 
            ++m_results->m_tests;
        }
 
    void success(const TQString &message) { m_results->m_successList.append(message); }
 
    void failure(const TQString &message) { m_results->m_errorList.append(message); }
 
    void expectedFailure(const TQString &message) { m_results->m_xfailList.append(message); }
 
    void unexpectedSuccess(const TQString &message) { m_results->m_xpassList.append(message); }
 
    void skipTest(const TQString &message) { m_results->m_skipList.append(message); }
 
    void setExceptionRaised(bool state) { m_exceptionState = state; }
 
    bool exceptionRaised() const
    {
    return m_exceptionState;
    }
 
    protected:
        TestResults *m_results;
 
    private:
 
    bool m_exceptionState;
    };
 
    class TDEUNITTEST_EXPORT SlotTester : public Tester
    {
        TQ_OBJECT
 
    public:
        SlotTester(const char *name = 0L);
 
        void allTests();
 
        TestResults *results(const char *sl);
 
        TestResultsListType &resultsList() { return m_resultsList; }
 
    signals:
        void invoke();
 
    private:
        void invokeMember(const TQString &str);
 
        TestResultsListType  m_resultsList;
        TestResults         *m_total;
    };
}
 
TDEUNITTEST_EXPORT TQTextStream& operator<<( TQTextStream& str, const TQRect& r );
 
TDEUNITTEST_EXPORT TQTextStream& operator<<( TQTextStream& str, const TQPoint& r );
 
TDEUNITTEST_EXPORT TQTextStream& operator<<( TQTextStream& str, const TQSize& r );
 
#endif