/*

* 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 CXETESTUTILS_H

#define CXETESTUTILS_H

#include <QSignalSpy>

#include "cxutils.h"

const int CXE_TEST_POLL_TIME = 10;

class CxeTestUtils

{

public:

    static bool waitForSignal(

        QSignalSpy &spy, int ms, int count = 1, bool allowExtraSignals = true);

    template<typename T> static bool waitForState(

        T& stateMachine, typename T::State state, int ms);

};

/**

* Wait for a state machine to transition to a given state. Returns false if

* target state is not reached withing the given timeout.

*

* This function expects the state machine to emit a

* "stateChanged(T::State...)" signal. Also, the state machine class needs to

* implement an enum called "State". Remember to use the

* Q_DECLARE_METATYPE macro for the State enum.

*

* waitForState() is template based so the implementation needs to be in the

* header file.

*

* @tparam T            State machine type

* @param  stateMachine State machine instance

* @param  state        Target state

* @param  ms           Timeout in milliseconds

* @return              True if target state was reached, false if timed out

*/

template<typename T> bool CxeTestUtils::waitForState(

    T& stateMachine, typename T::State state, int ms)

{

    int waitingTime = 0;

    bool stateReached = false;

    // Find stateChanged() signal

    QByteArray signalSignature;

    const QMetaObject *meta = stateMachine.metaObject();

    for (int i = 0; i < meta->methodCount(); i++) {

        QMetaMethod method = meta->method(i); 

        if (method.methodType() == QMetaMethod::Signal &&

            QByteArray(method.signature()).startsWith("stateChanged(")) {

            signalSignature = method.signature();

            signalSignature.prepend(QSIGNAL_CODE + '0');

        }

    }

    // Listen for stateChanged signals using signal spy

    QSignalSpy spy(&stateMachine, signalSignature.constData());

    if (!spy.isValid()) {

        CX_DEBUG(("waitForState() - unable to set up signal spy - is there a stateChanged() signal?"));

        return false;

    }

    // Loop for waiting for state changes. This terminates when

    // stateMachine.state() returns the target state, a stateChanged signal

    // indicates a state change to the target state, or the timeout is expired.

    while (!stateReached && waitingTime < ms) {

        QTest::qWait(CXE_TEST_POLL_TIME);

        waitingTime += CXE_TEST_POLL_TIME;

        // Check current state

        if (stateMachine.state() == state) {

            CX_DEBUG(("waitForState() - current state matches"));

            stateReached = true;

        }

        // Check state history from signal spy in case

        // there were quick successive state changes

        for (int i = 0; i < spy.count() && !stateReached; i++) {

            if (!spy[i].at(0).canConvert<T::State>()) {

                CX_DEBUG(("waitForState() - can't convert stateChanged params!"));

                CX_DEBUG(("waitForState() - signature is %s!", signalSignature.constData()));

                return false;

            }

            if (spy[i].at(0).value<T::State>() == state) {

                CX_DEBUG(("waitForState() - found signal spy state signal match"));

                stateReached = true;

            }

        }

    }

    if (stateReached) {

        CX_DEBUG(("waitForState() - got  to state %d successfully",

                  static_cast<int>(state)));

    } else {

        CX_DEBUG(("waitForState() - transition to state %d timed out (state is still %d), waitingTime = %d",

                static_cast<int>(state), static_cast<int>(stateMachine.state()), waitingTime));

    }

    return stateReached;

}

#endif // CXETESTUTILS_H