/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <QtCore/QCoreApplication>

#include <QtGui/QPushButton>

#include <QtGui/QGraphicsScene>

#include <QtGui/QGraphicsSceneEvent>

#include <QtGui/QGraphicsTextItem>

#include "qstatemachine.h"

#include "qstate.h"

#include "qhistorystate.h"

#include "qkeyeventtransition.h"

#include "qmouseeventtransition.h"

#include "private/qstate_p.h"

#include "private/qstatemachine_p.h"

// Will try to wait for the condition while allowing event processing

#define QTRY_COMPARE(__expr, __expected) \

    do { \

        const int __step = 50; \

        const int __timeout = 5000; \

        if ((__expr) != (__expected)) { \

            QTest::qWait(0); \

        } \

        for (int __i = 0; __i < __timeout && ((__expr) != (__expected)); __i+=__step) { \

            QTest::qWait(__step); \

        } \

        QCOMPARE(__expr, __expected); \

    } while(0)

//TESTED_CLASS=

//TESTED_FILES=

static int globalTick;

// Run exec for a maximum of TIMEOUT msecs

#define QCOREAPPLICATION_EXEC(TIMEOUT) \

{ \

    QTimer timer; \

    timer.setSingleShot(true); \

    timer.setInterval(TIMEOUT); \

    timer.start(); \

    connect(&timer, SIGNAL(timeout()), QCoreApplication::instance(), SLOT(quit())); \

    QCoreApplication::exec(); \

}

class SignalEmitter : public QObject

{

Q_OBJECT

    public:

    SignalEmitter(QObject *parent = 0)

        : QObject(parent) {}

    void emitSignalWithNoArg()

        { emit signalWithNoArg(); }

    void emitSignalWithIntArg(int arg)

        { emit signalWithIntArg(arg); }

    void emitSignalWithStringArg(const QString &arg)

        { emit signalWithStringArg(arg); }

    void emitSignalWithDefaultArg()

        { emit signalWithDefaultArg(); }

Q_SIGNALS:

    void signalWithNoArg();

    void signalWithIntArg(int);

    void signalWithStringArg(const QString &);

    void signalWithDefaultArg(int i = 42);

};

class tst_QStateMachine : public QObject

{

    Q_OBJECT

public:

    tst_QStateMachine();

    virtual ~tst_QStateMachine();

private slots:

    void init();

    void cleanup();

    void rootState();

    void machineWithParent();

    void addAndRemoveState();

    void stateEntryAndExit();

    void assignProperty();

    void assignPropertyWithAnimation();

    void postEvent();

    void cancelDelayedEvent();

    void postDelayedEventAndStop();

    void stopAndPostEvent();

    void stateFinished();

    void parallelStates();

    void parallelRootState();

    void allSourceToTargetConfigurations();

    void signalTransitions();

    void eventTransitions();

    void graphicsSceneEventTransitions();

    void historyStates();

    void startAndStop();

    void targetStateWithNoParent();

    void targetStateDeleted();

    void transitionToRootState();

    void transitionFromRootState();

    void transitionEntersParent();

    void defaultErrorState();

    void customGlobalErrorState();

    void customLocalErrorStateInBrokenState();

    void customLocalErrorStateInOtherState();

    void customLocalErrorStateInParentOfBrokenState();

    void customLocalErrorStateOverridesParent();

    void errorStateHasChildren();

    void errorStateHasErrors();

    void errorStateIsRootState();

    void errorStateEntersParentFirst();

    void customErrorStateIsNull();

    void clearError();

    void historyStateHasNowhereToGo();

    void historyStateAsInitialState();

    void brokenStateIsNeverEntered();

    void customErrorStateNotInGraph();

    void transitionToStateNotInGraph();

    void restoreProperties();

    void defaultGlobalRestorePolicy();

    void globalRestorePolicySetToRestore();

    void globalRestorePolicySetToDontRestore();

    void noInitialStateForInitialState();

    //void restorePolicyNotInherited();

    //void mixedRestoreProperties();

    //void setRestorePolicyToDoNotRestore();

    //void setGlobalRestorePolicyToGlobalRestore();

    //void restorePolicyOnChildState();

    void transitionWithParent();

    void transitionsFromParallelStateWithNoChildren();

    void parallelStateTransition();

    void parallelStateAssignmentsDone();

    void nestedRestoreProperties();

    void nestedRestoreProperties2();

    void simpleAnimation();

    void twoAnimations();

    void twoAnimatedTransitions();

    void playAnimationTwice();

    void nestedTargetStateForAnimation();

    void propertiesAssignedSignalTransitionsReuseAnimationGroup();

    void animatedGlobalRestoreProperty();

    void specificTargetValueOfAnimation();

    void addDefaultAnimation();

    void addDefaultAnimationWithUnusedAnimation();

    void removeDefaultAnimation();

    void overrideDefaultAnimationWithSpecific();

//    void addDefaultAnimationForSource();

//    void addDefaultAnimationForTarget();

//    void removeDefaultAnimationForSource();

//    void removeDefaultAnimationForTarget();

//    void overrideDefaultAnimationWithSource();

//    void overrideDefaultAnimationWithTarget();

//    void overrideDefaultSourceAnimationWithSpecific();

//    void overrideDefaultTargetAnimationWithSpecific();

//    void overrideDefaultTargetAnimationWithSource();

    void nestedStateMachines();

    void goToState();

    void task260403_clonedSignals();

    void postEventFromOtherThread();

    void eventFilterForApplication();

    void eventClassesExported();

};

tst_QStateMachine::tst_QStateMachine()

{

}

tst_QStateMachine::~tst_QStateMachine()

{

}

class TestState : public QState

{

public:

    enum Event {

        Entry,

        Exit

    };

    TestState(QState *parent)

        : QState(parent) {}

    QList<QPair<int, Event> > events;

protected:

    virtual void onEntry(QEvent *) {

        events.append(qMakePair(globalTick++, Entry));

    }

    virtual void onExit(QEvent *) {

        events.append(qMakePair(globalTick++, Exit));

    }

};

class TestTransition : public QAbstractTransition

{

public:

    TestTransition(QAbstractState *target)

        : QAbstractTransition()

    { setTargetState(target); }

    QList<int> triggers;

protected:

    virtual bool eventTest(QEvent *) {

        return true;

    }

    virtual void onTransition(QEvent *) {

        triggers.append(globalTick++);

    }

};

void tst_QStateMachine::init()

{

}

void tst_QStateMachine::cleanup()

{

}

class EventTransition : public QAbstractTransition

{

public:

    EventTransition(QEvent::Type type, QAbstractState *target, QState *parent = 0)

        : QAbstractTransition(parent), m_type(type)

    { setTargetState(target); }

protected:

    virtual bool eventTest(QEvent *e) {

        return (e->type() == m_type);

    }

    virtual void onTransition(QEvent *) {}

private:

    QEvent::Type m_type;

};

void tst_QStateMachine::transitionToRootState()

{

    QStateMachine machine;

    machine.setObjectName("machine");

    QState *initialState = new QState();

    initialState->setObjectName("initial");

    machine.addState(initialState);

    machine.setInitialState(initialState);

    QAbstractTransition *trans = new EventTransition(QEvent::User, &machine);

    initialState->addTransition(trans);

    QCOMPARE(trans->sourceState(), initialState);

    QCOMPARE(trans->targetState(), static_cast<QAbstractState *>(&machine));

    machine.start();

    QCoreApplication::processEvents();

    QCOMPARE(machine.configuration().count(), 1);

    QVERIFY(machine.configuration().contains(initialState));

    machine.postEvent(new QEvent(QEvent::User));

    QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: No common ancestor for targets and source of transition from state 'initial'");

    QCoreApplication::processEvents();

    QVERIFY(machine.configuration().isEmpty());

    QVERIFY(!machine.isRunning());

}

void tst_QStateMachine::transitionFromRootState()

{

    QStateMachine machine;

    QState *root = &machine;

    QState *s1 = new QState(root);

    EventTransition *trans = new EventTransition(QEvent::User, s1);

    root->addTransition(trans);

    QCOMPARE(trans->sourceState(), root);

    QCOMPARE(trans->targetState(), static_cast<QAbstractState *>(s1));

}

void tst_QStateMachine::transitionEntersParent()

{

    QStateMachine machine;

    QObject *entryController = new QObject(&machine);

    entryController->setObjectName("entryController");

    entryController->setProperty("greatGrandParentEntered", false);

    entryController->setProperty("grandParentEntered", false);

    entryController->setProperty("parentEntered", false);

    entryController->setProperty("stateEntered", false);

    QState *greatGrandParent = new QState();

    greatGrandParent->setObjectName("grandParent");

    greatGrandParent->assignProperty(entryController, "greatGrandParentEntered", true);

    machine.addState(greatGrandParent);

    machine.setInitialState(greatGrandParent);

    QState *grandParent = new QState(greatGrandParent);

    grandParent->setObjectName("grandParent");

    grandParent->assignProperty(entryController, "grandParentEntered", true);

    QState *parent = new QState(grandParent);

    parent->setObjectName("parent");

    parent->assignProperty(entryController, "parentEntered", true);

    QState *state = new QState(parent);

    state->setObjectName("state");

    state->assignProperty(entryController, "stateEntered", true);

    QState *initialStateOfGreatGrandParent = new QState(greatGrandParent);

    initialStateOfGreatGrandParent->setObjectName("initialStateOfGreatGrandParent");

    greatGrandParent->setInitialState(initialStateOfGreatGrandParent);

    initialStateOfGreatGrandParent->addTransition(new EventTransition(QEvent::User, state));

    machine.start();

    QCoreApplication::processEvents();

    QCOMPARE(entryController->property("greatGrandParentEntered").toBool(), true);

    QCOMPARE(entryController->property("grandParentEntered").toBool(), false);

    QCOMPARE(entryController->property("parentEntered").toBool(), false);

    QCOMPARE(entryController->property("stateEntered").toBool(), false);

    QCOMPARE(machine.configuration().count(), 2);

    QVERIFY(machine.configuration().contains(greatGrandParent));

    QVERIFY(machine.configuration().contains(initialStateOfGreatGrandParent));

    entryController->setProperty("greatGrandParentEntered", false);

    entryController->setProperty("grandParentEntered", false);

    entryController->setProperty("parentEntered", false);

    entryController->setProperty("stateEntered", false);

    machine.postEvent(new QEvent(QEvent::User));

    QCoreApplication::processEvents();

    QCOMPARE(entryController->property("greatGrandParentEntered").toBool(), false);

    QCOMPARE(entryController->property("grandParentEntered").toBool(), true);

    QCOMPARE(entryController->property("parentEntered").toBool(), true);

    QCOMPARE(entryController->property("stateEntered").toBool(), true);

    QCOMPARE(machine.configuration().count(), 4);

    QVERIFY(machine.configuration().contains(greatGrandParent));

    QVERIFY(machine.configuration().contains(grandParent));

    QVERIFY(machine.configuration().contains(parent));

    QVERIFY(machine.configuration().contains(state));

}

void tst_QStateMachine::defaultErrorState()

{

    QStateMachine machine;

    QCOMPARE(machine.errorState(), reinterpret_cast<QAbstractState *>(0));

    QState *brokenState = new QState();

    brokenState->setObjectName("MyInitialState");

    machine.addState(brokenState);

    machine.setInitialState(brokenState);

    QState *childState = new QState(brokenState);

    childState->setObjectName("childState");

    QTest::ignoreMessage(QtWarningMsg, "Unrecoverable error detected in running state machine: Missing initial state in compound state 'MyInitialState'");

    // initialState has no initial state

    machine.start();

    QCoreApplication::processEvents();

    QCOMPARE(machine.error(), QStateMachine::NoInitialStateError);

    QCOMPARE(machine.errorString(), QString::fromLatin1("Missing initial state in compound state 'MyInitialState'"));

    QCOMPARE(machine.isRunning(), false);

}

class CustomErrorState: public QState

{

public:

    CustomErrorState(QStateMachine *machine, QState *parent = 0)

        : QState(parent), error(QStateMachine::NoError), m_machine(machine)

    {

    }

    void onEntry(QEvent *)

    {

        error = m_machine->error();

        errorString = m_machine->errorString();

    }

    QStateMachine::Error error;

    QString errorString;

private:

    QStateMachine *m_machine;

};

void tst_QStateMachine::customGlobalErrorState()

{

    QStateMachine machine;

    CustomErrorState *customErrorState = new CustomErrorState(&machine);

    customErrorState->setObjectName("customErrorState");

    machine.addState(customErrorState);

    machine.setErrorState(customErrorState);

    QState *initialState = new QState();

    initialState->setObjectName("initialState");

    machine.addState(initialState);

    machine.setInitialState(initialState);

    QState *brokenState = new QState();

    brokenState->setObjectName("brokenState");

    machine.addState(brokenState);

    QState *childState = new QState(brokenState);

    childState->setObjectName("childState");

    initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));

    machine.start();

    QCoreApplication::processEvents();

    QCOMPARE(machine.errorState(), static_cast<QAbstractState*>(customErrorState));

    QCOMPARE(machine.configuration().count(), 1);

    QVERIFY(machine.configuration().contains(initialState));

    machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));

    QCOMPARE(machine.configuration().count(), 1);

    QVERIFY(machine.configuration().contains(initialState));

    QCoreApplication::processEvents();

    QCOMPARE(machine.isRunning(), true);

    QCOMPARE(machine.configuration().count(), 1);

    QVERIFY(machine.configuration().contains(customErrorState));

    QCOMPARE(customErrorState->error, QStateMachine::NoInitialStateError);

    QCOMPARE(customErrorState->errorString, QString::fromLatin1("Missing initial state in compound state 'brokenState'"));

    QCOMPARE(machine.error(), QStateMachine::NoInitialStateError);

    QCOMPARE(machine.errorString(), QString::fromLatin1("Missing initial state in compound state 'brokenState'"));

}

void tst_QStateMachine::customLocalErrorStateInBrokenState()

{

    QStateMachine machine;

    CustomErrorState *customErrorState = new CustomErrorState(&machine);

    machine.addState(customErrorState);

    QState *initialState = new QState();

    initialState->setObjectName("initialState");

    machine.addState(initialState);

    machine.setInitialState(initialState);

    QState *brokenState = new QState();

    brokenState->setObjectName("brokenState");

    machine.addState(brokenState);

    brokenState->setErrorState(customErrorState);

    QState *childState = new QState(brokenState);

    childState->setObjectName("childState");

    initialState->addTransition(new EventTransition(QEvent::Type(QEvent::User + 1), brokenState));

    machine.start();

    QCoreApplication::processEvents();

    machine.postEvent(new QEvent(QEvent::Type(QEvent::User + 1)));

    QCoreApplication::processEvents();

    QCOMPARE(machine.isRunning(), true);

    QCOMPARE(machine.configuration().count(), 1);

    QVERIFY(machine.configuration().contains(customErrorState));

    QCOMPARE(customErrorState->error, QStateMachine::NoInitialStateError);

}

void tst_QStateMachine::customLocalErrorStateInOtherState()

{

    QStateMachine machine;

    CustomErrorState *customErrorState = new CustomErrorState(&machine);

    machine.addState(customErrorState);

    QState *initialState = new QState();

    initialState->setObjectName("initialState");

    QTest::ignoreMessage(QtWarningMsg, "QState::setErrorState: error state cannot belong to a different state machine");

    initialState->setErrorState(customErrorState);

    machine.addState(initialState);

    machine.setInitialState(initialState);

    QState *brokenState = new QState();

    brokenState->setObjectName("brokenState");

    machine.addState(brokenState);

    QState *childState = new QState(brokenState);