/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/

#ifndef TESTUTILITIES_H
#define TESTUTILITIES_H

#include <qobject.h>
#include <qglobal.h>
#include <qlist.h>
#include <qmetaobject.h>
#include <QDebug>

/*! Provides services for OOM simulation and memory leak detection. */
class MemoryAllocator : public QObject
{
    Q_OBJECT
    
public:
    
    /*! Activates OOM simulation. */
    static void enableOomSimulation();
    
    /*! Disables OOM simulation. */
    static void disableOomSimulation();
    
    /*! Checks whether OOM simulation is active. */
    static bool isOomSimulationEnabled();
    
    /*! Returns current alloc fail index. */
    static int currentAllocFailIndex();
    
    /*! Allocates memory. */
    static void* alloc(std::size_t sz);
    
    /*! Frees allocated memory. */
    static void free(void *memoryAddress);
    
    /*! Checks that all memory allocated through this allocator is freed. */
    static void verifyMemoryAllocations();

private:
    
    static bool m_isOomSimulationEnabled;
    static int m_numOfAllocsSinceLastFail;
    static int m_allocFailIndex;
    static QList<void*> m_allocList;
};

/*! Provides services to run QTest cases with OOM simulation. */
class OomTestExecuter : public QObject
{
    Q_OBJECT
    
public:
    
    /*! Runs specified test case with OOM simulation. */
    template <typename CLASS>
    static void runTest(CLASS& testObject, void(CLASS::*testMethod)())
    {
        MemoryAllocator::enableOomSimulation();

        bool exceptionCaught = false;
        do {
            exceptionCaught = false;
            int currentAllocFailIndex = 
                MemoryAllocator::currentAllocFailIndex();
            
            try {
                try {
                    QMetaObject::invokeMethod(
                        &testObject, "init", Qt::DirectConnection);
                    (testObject.*testMethod)();
                } catch (const std::bad_alloc &ex) {
                    exceptionCaught = true;
                    QMetaObject::invokeMethod(
                        &testObject, "cleanup", Qt::DirectConnection);
                }
            // TODO: for some reason bad_alloc exception is corrupted to 
            // unknown exception and nested catch block is needed to be able to
            // handle situation. One level try-catch does not work for some reason.
            } catch (...) {
                exceptionCaught = true;
                QMetaObject::invokeMethod(
                    &testObject, "cleanup", Qt::DirectConnection);
                if (currentAllocFailIndex == MemoryAllocator::currentAllocFailIndex()) {
                    qDebug() << "OomTestExecuter::runTest, ERROR: unexpected exception!";
                    throw;
                }
            }
        } while(exceptionCaught);
        
        QMetaObject::invokeMethod(&testObject, "cleanup", Qt::DirectConnection);
        MemoryAllocator::disableOomSimulation();
    }

    /*! Runs specified test case with OOM simulation. */
    static void runTest(
        QObject &testObject, 
        const char *testMethod);
    
    /*! Runs all test cases in given QTest object with OOM simulation. */
    static void runAllTests(
        QObject &testObject, 
        const char *callingTestMethod);

private:
    
    static bool isValidSlot(const QMetaMethod &sl);
};

#define EXPECT_EXCEPTION(statements)    \
{                                       \
    bool exceptionDetected = false;     \
    try {                               \
        statements                      \
    } catch (...) {                     \
        exceptionDetected = true;       \
    }                                   \
    QVERIFY(true == exceptionDetected); \
}

#define QTEST_MAIN_S60(TestObject) \
int main(int argc, char *argv[]) \
{ \
    char *new_argv[3]; \
    QCoreApplication app(argc, argv); \
    \
    QString str = "C:\\data\\" + QFileInfo(QCoreApplication::applicationFilePath()).baseName() + ".log"; \
    QByteArray   bytes  = str.toAscii(); \
    \
    char arg1[] = "-o"; \
    \
    new_argv[0] = argv[0]; \
    new_argv[1] = arg1; \
    new_argv[2] = bytes.data(); \
    \
    TestObject tc; \
    int result = QTest::qExec(&tc, 3, new_argv); \
    \
    MemoryAllocator::verifyMemoryAllocations(); \
    \
    return result;\
}

#endif  // TESTUTILITIES_H