/*
* 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:
*
*/

#include <QByteArray>
#include "testutilities.h"

/*!
  Replaces global new operator for utilizing binary. Enables OOM 
  simulation and memory leak detection.
  
  Note that creation of CBase derived Symbian classes 
  are not tracked, because CBase overloads new operator. 
 */
void* operator new(std::size_t sz) throw(std::bad_alloc)
{
    return MemoryAllocator::alloc(sz);
}

/*!
  Replaces global delete operator for utilizing binary. Enables OOM 
  simulation and memory leak detection. 
 */
void operator delete(void* memoryAddr) throw()
{
    return MemoryAllocator::free(memoryAddr);
}

void* operator new(std::size_t sz, const std::nothrow_t&) throw()
{
    return qMalloc(sz);
}

void  operator delete(void* memoryAddress, const std::nothrow_t&) throw()
{
    if (NULL != memoryAddress) {
        qFree(memoryAddress);
    }
}

bool MemoryAllocator::m_isOomSimulationEnabled = false;
int MemoryAllocator::m_numOfAllocsSinceLastFail = 0;
int MemoryAllocator::m_allocFailIndex = 1;
QList<void*> MemoryAllocator::m_allocList;

/*!
  MemoryAllocator::enableOomSimulation
 */
void MemoryAllocator::enableOomSimulation()
{
    m_isOomSimulationEnabled = true;
    m_allocFailIndex = 1;
    m_numOfAllocsSinceLastFail = 0;
}

/*!
  MemoryAllocator::disableOomSimulation
 */
void MemoryAllocator::disableOomSimulation()
{
    m_isOomSimulationEnabled = false;
}

/*!
  MemoryAllocator::isOomSimulationEnabled
 */
bool MemoryAllocator::isOomSimulationEnabled()
{
    return m_isOomSimulationEnabled;
}

/*!
  MemoryAllocator::currentAllocFailIndex
 */
int MemoryAllocator::currentAllocFailIndex()
{
    return m_allocFailIndex;
}

/*!
  MemoryAllocator::alloc
 */
void* MemoryAllocator::alloc(std::size_t sz)
{
    if (isOomSimulationEnabled()) {
        m_numOfAllocsSinceLastFail++;
        if (m_allocFailIndex == m_numOfAllocsSinceLastFail) {
            m_allocFailIndex++;
            m_numOfAllocsSinceLastFail = 0;
#ifdef QT_NO_EXCEPTIONS
            return NULL;
#else
            throw std::bad_alloc();
#endif
        }
    }
    
    void *allocatedMemoryAddr = qMalloc(sz);
    m_allocList.append(allocatedMemoryAddr);
    return allocatedMemoryAddr;
}

/*!
  MemoryAllocator::free
 */
void MemoryAllocator::free(void *memoryAddress)
{
    if (memoryAddress) {
        int index = m_allocList.indexOf(memoryAddress);
        if (-1 != index) {
            m_allocList.removeAt(index);
        }
        qFree(memoryAddress);
    }
}

/*!
  MemoryAllocator::verifyMemoryAllocations
 */
void MemoryAllocator::verifyMemoryAllocations()
{
    int numOfUnfreedCells = m_allocList.count();
    if (0 != numOfUnfreedCells) {
        for ( int i = 0; i < numOfUnfreedCells; i++) {
            qDebug("UNFREED CELL: %x", reinterpret_cast<int>(m_allocList.at(i)));
        }
    
    m_allocList.clear();
    throw std::bad_alloc();
    }
    
    m_allocList.clear();
}


/*!
  OomTestExecuter::runTest
 */
void OomTestExecuter::runTest(
    QObject &testObject, const char *testMethod)
{
    qDebug() << "OomTestExecuter::runTest : IN :" << testMethod;
    
    MemoryAllocator::enableOomSimulation();

    bool exceptionCaught = false;
    do {
        exceptionCaught = false;
        int currentAllocFailIndex = MemoryAllocator::currentAllocFailIndex();
        
        try {
            try {
                QMetaObject::invokeMethod(
                    &testObject, "init", Qt::DirectConnection);
                QMetaObject::invokeMethod(
                    &testObject, testMethod, Qt::DirectConnection);
            } 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 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();
    qDebug() << "OomTestExecuter::runTest : OUT :" << testMethod;
}

/*!
  OomTestExecuter::runAllTests
 */
void OomTestExecuter::runAllTests(
    QObject &testObject, const char *callingTestMethod)
{
    const QMetaObject *metaObject = testObject.metaObject();
    
    int methodCount = metaObject->methodCount();
    for (int i = 0; i < methodCount; ++i) {
        QMetaMethod slotMethodCandidate = metaObject->method(i);
        if (!isValidSlot(slotMethodCandidate)) {
            continue;
        }
        
        QByteArray slotMethodName(slotMethodCandidate.signature());
        // remove parentheses
        slotMethodName = slotMethodName.left(slotMethodName.length() - 2);
        
        // Prevent from infinite loop and do not execute test method, which
        // has called runAllTests.
        if (slotMethodName != callingTestMethod) {
            runTest(testObject, slotMethodName);
        }
    }
}

/*!
  OomTestExecuter::isValidSlot
 */
bool OomTestExecuter::isValidSlot(const QMetaMethod &sl)
{
    if ((sl.access() != QMetaMethod::Private) || !sl.parameterTypes().isEmpty()
        || qstrlen(sl.typeName()) || (sl.methodType() != QMetaMethod::Slot)) {
        return false;
    }
    
    const char *sig = sl.signature();
    int len = qstrlen(sig);
    if (len < 2) {
        return false;
    }
    
    if (sig[len - 2] != '(' || sig[len - 1] != ')') {
        return false;
    }
    
    if (len > 7 && strcmp(sig + (len - 7), "_data()") == 0) {
        return false;
    }
    
    if ((strcmp(sig, "initTestCase()") == 0) || (strcmp(sig, "cleanupTestCase()") == 0)
        || (strcmp(sig, "cleanup()") == 0) || (strcmp(sig, "init()") == 0)) {
        return false;
    }
    
    return true;
}