1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtTest/QtTest>

    43 #include <QtCore/QCoreApplication>

    44 #include <QtGui/QPushButton>

    45 #include <QtGui/QGraphicsScene>

    46 #include <QtGui/QGraphicsSceneEvent>

    47 #include <QtGui/QGraphicsTextItem>

    48 

    49 #include "qstatemachine.h"

    50 #include "qstate.h"

    51 #include "qhistorystate.h"

    52 #include "qkeyeventtransition.h"

    53 #include "qmouseeventtransition.h"

    54 #include "private/qstate_p.h"

    55 #include "private/qstatemachine_p.h"

    56 

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

    58 #define QTRY_COMPARE(__expr, __expected) \

    59     do { \

    60         const int __step = 50; \

    61         const int __timeout = 5000; \

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

    63             QTest::qWait(0); \

    64         } \

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

    66             QTest::qWait(__step); \

    67         } \

    68         QCOMPARE(__expr, __expected); \

    69     } while(0)

    70 

    71 //TESTED_CLASS=

    72 //TESTED_FILES=

    73 

    74 static int globalTick;

    75 

    76 // Run exec for a maximum of TIMEOUT msecs

    77 #define QCOREAPPLICATION_EXEC(TIMEOUT) \

    78 { \

    79     QTimer timer; \

    80     timer.setSingleShot(true); \

    81     timer.setInterval(TIMEOUT); \

    82     timer.start(); \

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

    84     QCoreApplication::exec(); \

    85 }

    86 

    87 class SignalEmitter : public QObject

    88 {

    89 Q_OBJECT

    90     public:

    91     SignalEmitter(QObject *parent = 0)

    92         : QObject(parent) {}

    93     void emitSignalWithNoArg()

    94         { emit signalWithNoArg(); }

    95     void emitSignalWithIntArg(int arg)

    96         { emit signalWithIntArg(arg); }

    97     void emitSignalWithStringArg(const QString &arg)

    98         { emit signalWithStringArg(arg); }

    99     void emitSignalWithDefaultArg()

   100         { emit signalWithDefaultArg(); }

   101 Q_SIGNALS:

   102     void signalWithNoArg();

   103     void signalWithIntArg(int);

   104     void signalWithStringArg(const QString &);

   105     void signalWithDefaultArg(int i = 42);

   106 };

   107 

   108 class tst_QStateMachine : public QObject

   109 {

   110     Q_OBJECT

   111 public:

   112     tst_QStateMachine();

   113     virtual ~tst_QStateMachine();

   114 

   115 private slots:

   116     void init();

   117     void cleanup();

   118 

   119     void rootState();

   120     void addAndRemoveState();

   121     void stateEntryAndExit();

   122     void assignProperty();

   123     void assignPropertyWithAnimation();

   124     void postEvent();

   125     void cancelDelayedEvent();

   126     void postDelayedEventAndStop();

   127     void stateFinished();

   128     void parallelStates();

   129     void parallelRootState();

   130     void allSourceToTargetConfigurations();

   131     void signalTransitions();

   132     void eventTransitions();

   133     void graphicsSceneEventTransitions();

   134     void historyStates();

   135     void startAndStop();

   136     void targetStateWithNoParent();

   137     void targetStateDeleted();

   138     void transitionToRootState();

   139     void transitionFromRootState();

   140     void transitionEntersParent();

   141 

   142     void defaultErrorState();

   143     void customGlobalErrorState();

   144     void customLocalErrorStateInBrokenState();

   145     void customLocalErrorStateInOtherState();

   146     void customLocalErrorStateInParentOfBrokenState();

   147     void customLocalErrorStateOverridesParent();

   148     void errorStateHasChildren();

   149     void errorStateHasErrors();

   150     void errorStateIsRootState();

   151     void errorStateEntersParentFirst();

   152     void customErrorStateIsNull();

   153     void clearError();

   154     void historyStateHasNowhereToGo();

   155     void historyStateAsInitialState();

   156     void brokenStateIsNeverEntered();

   157     void customErrorStateNotInGraph();

   158     void transitionToStateNotInGraph();

   159     void restoreProperties();

   160 

   161     void defaultGlobalRestorePolicy();

   162     void globalRestorePolicySetToRestore();

   163     void globalRestorePolicySetToDoNotRestore();

   164 

   165     void noInitialStateForInitialState();

   166 

   167     //void restorePolicyNotInherited();

   168     //void mixedRestoreProperties();

   169     //void setRestorePolicyToDoNotRestore();

   170     //void setGlobalRestorePolicyToGlobalRestore();

   171     //void restorePolicyOnChildState();

   172 

   173     void transitionWithParent();

   174     void transitionsFromParallelStateWithNoChildren();

   175     void parallelStateTransition();

   176     void parallelStateAssignmentsDone();

   177     void nestedRestoreProperties();

   178     void nestedRestoreProperties2();

   179 

   180     void simpleAnimation();

   181     void twoAnimations();

   182     void twoAnimatedTransitions();

   183     void playAnimationTwice();

   184     void nestedTargetStateForAnimation();

   185     void polishedSignalTransitionsReuseAnimationGroup();

   186     void animatedGlobalRestoreProperty();

   187     void specificTargetValueOfAnimation();

   188 

   189     void addDefaultAnimation();

   190     void addDefaultAnimationWithUnusedAnimation();

   191     void removeDefaultAnimation();

   192     void overrideDefaultAnimationWithSpecific();

   193 

   194 //    void addDefaultAnimationForSource();

   195 //    void addDefaultAnimationForTarget();

   196 //    void removeDefaultAnimationForSource();

   197 //    void removeDefaultAnimationForTarget();

   198 //    void overrideDefaultAnimationWithSource();

   199 //    void overrideDefaultAnimationWithTarget();

   200 //    void overrideDefaultSourceAnimationWithSpecific();

   201 //    void overrideDefaultTargetAnimationWithSpecific();

   202 //    void overrideDefaultTargetAnimationWithSource();

   203 

   204     void nestedStateMachines();

   205     void goToState();

   206 

   207     void task260403_clonedSignals();

   208 };

   209 

   210 tst_QStateMachine::tst_QStateMachine()

   211 {

   212 }

   213 

   214 tst_QStateMachine::~tst_QStateMachine()

   215 {

   216 }

   217 

   218 class TestState : public QState

   219 {

   220 public:

   221     enum Event {

   222         Entry,

   223         Exit

   224     };

   225     TestState(QState *parent)

   226         : QState(parent) {}

   227     QList<QPair<int, Event> > events;

   228 protected:

   229     virtual void onEntry(QEvent *) {

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

   231     }

   232     virtual void onExit(QEvent *) {

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

   234     }

   235 };

   236 

   237 class TestTransition : public QAbstractTransition

   238 {

   239 public:

   240     TestTransition(QAbstractState *target)

   241         : QAbstractTransition()

   242     { setTargetState(target); }

   243     QList<int> triggers;

   244 protected:

   245     virtual bool eventTest(QEvent *) {

   246         return true;

   247     }

   248     virtual void onTransition(QEvent *) {

   249         triggers.append(globalTick++);

   250     }

   251 };

   252 

   253 void tst_QStateMachine::init()

   254 {

   255 }

   256 

   257 void tst_QStateMachine::cleanup()

   258 {

   259 }

   260 

   261 class EventTransition : public QAbstractTransition

   262 {

   263 public:

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

   265         : QAbstractTransition(parent), m_type(type)

   266     { setTargetState(target); }

   267 protected:

   268     virtual bool eventTest(QEvent *e) {

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

   270     }

   271     virtual void onTransition(QEvent *) {}

   272 private:

   273     QEvent::Type m_type;

   274 };

   275 

   276 void tst_QStateMachine::transitionToRootState()

   277 {

   278     QStateMachine machine;

   279     machine.setObjectName("machine");

   280 

   281     QState *initialState = new QState();

   282     initialState->setObjectName("initial");

   283     machine.addState(initialState);

   284     machine.setInitialState(initialState);

   285 

   286     QAbstractTransition *trans = initialState->addTransition(new EventTransition(QEvent::User, &machine));

   287     QVERIFY(trans != 0);

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

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

   290 

   291     machine.start();

   292     QCoreApplication::processEvents();

   293 

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

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

   296 

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

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

   299     QCoreApplication::processEvents();

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

   301     QVERIFY(!machine.isRunning());

   302 }

   303 

   304 void tst_QStateMachine::transitionFromRootState()

   305 {

   306     QStateMachine machine;

   307     QState *root = &machine;

   308     QState *s1 = new QState(root);

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

   310     QCOMPARE(root->addTransition(trans), static_cast<QAbstractTransition *>(trans));

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

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

   313 }

   314 

   315 void tst_QStateMachine::transitionEntersParent()

   316 {

   317     QStateMachine machine;

   318 

   319     QObject *entryController = new QObject(&machine);

   320     entryController->setObjectName("entryController");

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

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

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

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

   325 

   326     QState *greatGrandParent = new QState();

   327     greatGrandParent->setObjectName("grandParent");

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

   329     machine.addState(greatGrandParent);

   330     machine.setInitialState(greatGrandParent);

   331 

   332     QState *grandParent = new QState(greatGrandParent);

   333     grandParent->setObjectName("grandParent");

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

   335 

   336     QState *parent = new QState(grandParent);

   337     parent->setObjectName("parent");

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

   339 

   340     QState *state = new QState(parent);

   341     state->setObjectName("state");

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

   343 

   344     QState *initialStateOfGreatGrandParent = new QState(greatGrandParent);

   345     initialStateOfGreatGrandParent->setObjectName("initialStateOfGreatGrandParent");

   346     greatGrandParent->setInitialState(initialStateOfGreatGrandParent);

   347 

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

   349 

   350     machine.start();

   351     QCoreApplication::processEvents();

   352 

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

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

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

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

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

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

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

   360 

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

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

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

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

   365 

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

   367     QCoreApplication::processEvents();

   368 

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

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

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

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

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

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

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

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

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

   378 }

   379 

   380 void tst_QStateMachine::defaultErrorState()

   381 {

   382     QStateMachine machine;

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

   384 

   385     QState *brokenState = new QState();

   386     brokenState->setObjectName("MyInitialState");

   387 

   388     machine.addState(brokenState);

   389     machine.setInitialState(brokenState);

   390 

   391     QState *childState = new QState(brokenState);

   392     childState->setObjectName("childState");

   393 

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

   395 

   396     // initialState has no initial state

   397     machine.start();

   398     QCoreApplication::processEvents();

   399 

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

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

   402     QCOMPARE(machine.isRunning(), false);

   403 }

   404 

   405 class CustomErrorState: public QState

   406 {

   407 public:

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

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

   410     {

   411     }

   412 

   413     void onEntry(QEvent *)

   414     {

   415         error = m_machine->error();

   416         errorString = m_machine->errorString();

   417     }

   418 

   419     QStateMachine::Error error;

   420     QString errorString;

   421 

   422 private:

   423     QStateMachine *m_machine;

   424 };

   425 

   426 void tst_QStateMachine::customGlobalErrorState()

   427 {

   428     QStateMachine machine;

   429 

   430     CustomErrorState *customErrorState = new CustomErrorState(&machine);

   431     customErrorState->setObjectName("customErrorState");

   432     machine.addState(customErrorState);

   433     machine.setErrorState(customErrorState);

   434 

   435     QState *initialState = new QState();

   436     initialState->setObjectName("initialState");

   437     machine.addState(initialState);

   438     machine.setInitialState(initialState);

   439 

   440     QState *brokenState = new QState();

   441     brokenState->setObjectName("brokenState");

   442     machine.addState(brokenState);

   443     QState *childState = new QState(brokenState);

   444     childState->setObjectName("childState");

   445 

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

   447     machine.start();

   448     QCoreApplication::processEvents();

   449 

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

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

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

   453 

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

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

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

   457 

   458     QCoreApplication::processEvents();

   459 

   460     QCOMPARE(machine.isRunning(), true);

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

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

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

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

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

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

   467 }

   468 

   469 void tst_QStateMachine::customLocalErrorStateInBrokenState()

   470 {

   471     QStateMachine machine;

   472     CustomErrorState *customErrorState = new CustomErrorState(&machine);

   473     machine.addState(customErrorState);

   474 

   475     QState *initialState = new QState();

   476     initialState->setObjectName("initialState");

   477     machine.addState(initialState);

   478     machine.setInitialState(initialState);

   479 

   480     QState *brokenState = new QState();

   481     brokenState->setObjectName("brokenState");

   482     machine.addState(brokenState);

   483     brokenState->setErrorState(customErrorState);

   484 

   485     QState *childState = new QState(brokenState);

   486     childState->setObjectName("childState");

   487 

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

   489 

   490     machine.start();

   491     QCoreApplication::processEvents();

   492 

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

   494     QCoreApplication::processEvents();

   495 

   496     QCOMPARE(machine.isRunning(), true);

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

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

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

   500 }

   501 

   502 void tst_QStateMachine::customLocalErrorStateInOtherState()

   503 {

   504     QStateMachine machine;

   505     CustomErrorState *customErrorState = new CustomErrorState(&machine);

   506     machine.addState(customErrorState);

   507 

   508     QState *initialState = new QState();

   509     initialState->setObjectName("initialState");

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

   511     initialState->setErrorState(customErrorState);

   512     machine.addState(initialState);

   513     machine.setInitialState(initialState);

   514 

   515     QState *brokenState = new QState();

   516     brokenState->setObjectName("brokenState");

   517 

   518     machine.addState(brokenState);

   519 

   520     QState *childState = new QState(brokenState);

   521     childState->setObjectName("childState");

   522 

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

   524 

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

   526     machine.start();

   527     QCoreApplication::processEvents();

   528 

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

   530     QCoreApplication::processEvents();

   531 

   532     QCOMPARE(machine.isRunning(), false);

   533 }

   534 

   535 void tst_QStateMachine::customLocalErrorStateInParentOfBrokenState()

   536 {

   537     QStateMachine machine;

   538     CustomErrorState *customErrorState = new CustomErrorState(&machine);

   539     machine.addState(customErrorState);

   540 

   541     QState *initialState = new QState();

   542     initialState->setObjectName("initialState");

   543     machine.addState(initialState);

   544     machine.setInitialState(initialState);

   545 

   546     QState *parentOfBrokenState = new QState();

   547     machine.addState(parentOfBrokenState);

   548     parentOfBrokenState->setObjectName("parentOfBrokenState");

   549     parentOfBrokenState->setErrorState(customErrorState);

   550 

   551     QState *brokenState = new QState(parentOfBrokenState);

   552     brokenState->setObjectName("brokenState");

   553     parentOfBrokenState->setInitialState(brokenState);

   554 

   555     QState *childState = new QState(brokenState);

   556     childState->setObjectName("childState");

   557 

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

   559 

   560     machine.start();

   561     QCoreApplication::processEvents();

   562 

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

   564     QCoreApplication::processEvents();

   565 

   566     QCOMPARE(machine.isRunning(), true);

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

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

   569 }

   570 

   571 void tst_QStateMachine::customLocalErrorStateOverridesParent()

   572 {

   573     QStateMachine machine;

   574     CustomErrorState *customErrorStateForParent = new CustomErrorState(&machine);

   575     machine.addState(customErrorStateForParent);

   576 

   577     CustomErrorState *customErrorStateForBrokenState = new CustomErrorState(&machine);

   578     machine.addState(customErrorStateForBrokenState);

   579 

   580     QState *initialState = new QState();

   581     initialState->setObjectName("initialState");

   582     machine.addState(initialState);

   583     machine.setInitialState(initialState);

   584 

   585     QState *parentOfBrokenState = new QState();

   586     machine.addState(parentOfBrokenState);

   587     parentOfBrokenState->setObjectName("parentOfBrokenState");

   588     parentOfBrokenState->setErrorState(customErrorStateForParent);

   589 

   590     QState *brokenState = new QState(parentOfBrokenState);

   591     brokenState->setObjectName("brokenState");

   592     brokenState->setErrorState(customErrorStateForBrokenState);

   593     parentOfBrokenState->setInitialState(brokenState);

   594 

   595     QState *childState = new QState(brokenState);

   596     childState->setObjectName("childState");

   597 

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

   599 

   600     machine.start();

   601     QCoreApplication::processEvents();

   602 

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

   604     QCoreApplication::processEvents();

   605 

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

   607     QVERIFY(machine.configuration().contains(customErrorStateForBrokenState));

   608     QCOMPARE(customErrorStateForBrokenState->error, QStateMachine::NoInitialStateError);

   609     QCOMPARE(customErrorStateForParent->error, QStateMachine::NoError);

   610 }

   611 

   612 void tst_QStateMachine::errorStateHasChildren()

   613 {

   614     QStateMachine machine;

   615     CustomErrorState *customErrorState = new CustomErrorState(&machine);

   616     customErrorState->setObjectName("customErrorState");

   617     machine.addState(customErrorState);

   618 

   619     machine.setErrorState(customErrorState);

   620 

   621     QState *childOfErrorState = new QState(customErrorState);

   622     childOfErrorState->setObjectName("childOfErrorState");

   623     customErrorState->setInitialState(childOfErrorState);

   624 

   625     QState *initialState = new QState();

   626     initialState->setObjectName("initialState");

   627     machine.addState(initialState);

   628     machine.setInitialState(initialState);

   629 

   630     QState *brokenState = new QState();

   631     brokenState->setObjectName("brokenState");

   632     machine.addState(brokenState);

   633 

   634     QState *childState = new QState(brokenState);

   635     childState->setObjectName("childState");

   636 

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

   638 

   639     machine.start();

   640     QCoreApplication::processEvents();

   641 

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

   643     QCoreApplication::processEvents();

   644 

   645     QCOMPARE(machine.isRunning(), true);

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

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

   648     QVERIFY(machine.configuration().contains(childOfErrorState));

   649 }

   650 

   651 

   652 void tst_QStateMachine::errorStateHasErrors()

   653 {

   654     QStateMachine machine;

   655     CustomErrorState *customErrorState = new CustomErrorState(&machine);

   656     customErrorState->setObjectName("customErrorState");

   657     machine.addState(customErrorState);

   658 

   659     machine.setErrorState(customErrorState);

   660 

   661     QState *childOfErrorState = new QState(customErrorState);

   662     childOfErrorState->setObjectName("childOfErrorState");

   663 

   664     QState *initialState = new QState();

   665     initialState->setObjectName("initialState");

   666     machine.addState(initialState);

   667     machine.setInitialState(initialState);

   668 

   669     QState *brokenState = new QState();

   670     brokenState->setObjectName("brokenState");

   671     machine.addState(brokenState);

   672 

   673     QState *childState = new QState(brokenState);

   674     childState->setObjectName("childState");

   675 

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

   677 

   678     machine.start();

   679     QCoreApplication::processEvents();

   680 

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

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

   683     QCoreApplication::processEvents();

   684 

   685     QCOMPARE(machine.isRunning(), false);

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

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

   688 }

   689 

   690 void tst_QStateMachine::errorStateIsRootState()

   691 {

   692     QStateMachine machine;

   693     QTest::ignoreMessage(QtWarningMsg, "QStateMachine::setErrorState: root state cannot be error state");

   694     machine.setErrorState(&machine);

   695 

   696     QState *initialState = new QState();

   697     initialState->setObjectName("initialState");

   698     machine.addState(initialState);

   699     machine.setInitialState(initialState);

   700 

   701     QState *brokenState = new QState();

   702     brokenState->setObjectName("brokenState");

   703     machine.addState(brokenState);

   704 

   705     QState *childState = new QState(brokenState);

   706     childState->setObjectName("childState");

   707 

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

   709 

   710     machine.start();

   711     QCoreApplication::processEvents();

   712 

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

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

   715     QCoreApplication::processEvents();

   716 

   717     QCOMPARE(machine.isRunning(), false);

   718 }

   719 

   720 void tst_QStateMachine::errorStateEntersParentFirst()

   721 {

   722     QStateMachine machine;

   723 

   724     QObject *entryController = new QObject(&machine);

   725     entryController->setObjectName("entryController");

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

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

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

   729     entryController->setProperty("errorStateEntered", false);

   730 

   731     QState *greatGrandParent = new QState();

   732     greatGrandParent->setObjectName("greatGrandParent");

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

   734     machine.addState(greatGrandParent);

   735     machine.setInitialState(greatGrandParent);

   736 

   737     QState *grandParent = new QState(greatGrandParent);

   738     grandParent->setObjectName("grandParent");

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

   740 

   741     QState *parent = new QState(grandParent);

   742     parent->setObjectName("parent");

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

   744 

   745     QState *errorState = new QState(parent);

   746     errorState->setObjectName("errorState");

   747     errorState->assignProperty(entryController, "errorStateEntered", true);

   748     machine.setErrorState(errorState);

   749 

   750     QState *initialStateOfGreatGrandParent = new QState(greatGrandParent);

   751     initialStateOfGreatGrandParent->setObjectName("initialStateOfGreatGrandParent");

   752     greatGrandParent->setInitialState(initialStateOfGreatGrandParent);

   753 

   754     QState *brokenState = new QState(greatGrandParent);

   755     brokenState->setObjectName("brokenState");

   756 

   757     QState *childState = new QState(brokenState);

   758     childState->setObjectName("childState");

   759 

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

   761 

   762     machine.start();

   763     QCoreApplication::processEvents();

   764 

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

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

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

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

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

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

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

   772 

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

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

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

   776     entryController->setProperty("errorStateEntered", false);

   777 

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

   779     QCoreApplication::processEvents();

   780 

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

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

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

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

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

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

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

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

   789     QVERIFY(machine.configuration().contains(errorState));

   790 }

   791 

   792 void tst_QStateMachine::customErrorStateIsNull()

   793 {

   794     QStateMachine machine;

   795     machine.setErrorState(0);

   796 

   797     QState *initialState = new QState();

   798     machine.addState(initialState);

   799     machine.setInitialState(initialState);

   800 

   801     QState *brokenState = new QState();

   802     machine.addState(brokenState);

   803 

   804     new QState(brokenState);

   805     initialState->addTransition(new EventTransition(QEvent::User, brokenState));

   806 

   807     machine.start();

   808     QCoreApplication::processEvents();

   809 

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

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

   812     QCoreApplication::processEvents();

   813 

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

   815     QCOMPARE(machine.isRunning(), false);

   816 }

   817 

   818 void tst_QStateMachine::clearError()

   819 {

   820     QStateMachine machine;

   821     machine.setErrorState(new QState(&machine)); // avoid warnings

   822 

   823     QState *brokenState = new QState(&machine);

   824     brokenState->setObjectName("brokenState");

   825     machine.setInitialState(brokenState);

   826     new QState(brokenState);

   827 

   828     machine.start();

   829     QCoreApplication::processEvents();

   830 

   831     QCOMPARE(machine.isRunning(), true);

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

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

   834 

   835     machine.clearError();

   836 

   837     QCOMPARE(machine.error(), QStateMachine::NoError);

   838     QVERIFY(machine.errorString().isEmpty());

   839 }

   840 

   841 void tst_QStateMachine::historyStateAsInitialState()

   842 {

   843     QStateMachine machine;

   844 

   845     QHistoryState *hs = new QHistoryState(&machine);

   846     machine.setInitialState(hs);

   847 

   848     QState *s1 = new QState(&machine);

   849     hs->setDefaultState(s1);

   850 

   851     QState *s2 = new QState(&machine);

   852 

   853     QHistoryState *s2h = new QHistoryState(s2);

   854     s2->setInitialState(s2h);

   855 

   856     QState *s21 = new QState(s2);

   857     s2h->setDefaultState(s21);

   858 

   859     s1->addTransition(new EventTransition(QEvent::User, s2));

   860 

   861     machine.start();

   862     QCoreApplication::processEvents();

   863 

   864     QCOMPARE(machine.configuration().size(), 1);

   865     QVERIFY(machine.configuration().contains(s1));

   866 

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

   868     QCoreApplication::processEvents();

   869 

   870     QCOMPARE(machine.configuration().size(), 2);

   871     QVERIFY(machine.configuration().contains(s2));

   872     QVERIFY(machine.configuration().contains(s21));

   873 }

   874 

   875 void tst_QStateMachine::historyStateHasNowhereToGo()

   876 {

   877     QStateMachine machine;

   878 

   879     QState *initialState = new QState(&machine);

   880     machine.setInitialState(initialState);

   881     machine.setErrorState(new QState(&machine)); // avoid warnings

   882 

   883     QState *brokenState = new QState(&machine);

   884     brokenState->setObjectName("brokenState");

   885     brokenState->setInitialState(new QState(brokenState));

   886 

   887     QHistoryState *historyState = new QHistoryState(brokenState);

   888     historyState->setObjectName("historyState");

   889     initialState->addTransition(new EventTransition(QEvent::User, historyState));

   890 

   891     machine.start();

   892     QCoreApplication::processEvents();

   893 

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

   895     QCoreApplication::processEvents();

   896 

   897     QCOMPARE(machine.isRunning(), true);

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

   899     QVERIFY(machine.configuration().contains(machine.errorState()));

   900     QCOMPARE(machine.error(), QStateMachine::NoDefaultStateInHistoryStateError);

   901     QCOMPARE(machine.errorString(), QString::fromLatin1("Missing default state in history state 'historyState'"));

   902 }

   903 

   904 void tst_QStateMachine::brokenStateIsNeverEntered()

   905 {

   906     QStateMachine machine;

   907 

   908     QObject *entryController = new QObject(&machine);

   909     entryController->setProperty("brokenStateEntered", false);

   910     entryController->setProperty("childStateEntered", false);

   911     entryController->setProperty("errorStateEntered", false);

   912 

   913     QState *initialState = new QState(&machine);

   914     machine.setInitialState(initialState);

   915 

   916     QState *errorState = new QState(&machine);

   917     errorState->assignProperty(entryController, "errorStateEntered", true);

   918     machine.setErrorState(errorState);

   919 

   920     QState *brokenState = new QState(&machine);

   921     brokenState->assignProperty(entryController, "brokenStateEntered", true);

   922     brokenState->setObjectName("brokenState");

   923 

   924     QState *childState = new QState(brokenState);

   925     childState->assignProperty(entryController, "childStateEntered", true);

   926 

   927     initialState->addTransition(new EventTransition(QEvent::User, brokenState));

   928 

   929     machine.start();

   930     QCoreApplication::processEvents();

   931 

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

   933     QCoreApplication::processEvents();

   934 

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

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

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

   938 }

   939 

   940 void tst_QStateMachine::transitionToStateNotInGraph()

   941 {

   942     QStateMachine machine;

   943 

   944     QState *initialState = new QState(&machine);

   945     initialState->setObjectName("initialState");

   946     machine.setInitialState(initialState);

   947 

   948     QState independentState;

   949     independentState.setObjectName("independentState");

   950     initialState->addTransition(&independentState);

   951 

   952     machine.start();

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

   954     QCoreApplication::processEvents();

   955 

   956     QCOMPARE(machine.isRunning(), false);

   957 }

   958 

   959 void tst_QStateMachine::customErrorStateNotInGraph()

   960 {

   961     QStateMachine machine;

   962 

   963     QState errorState;

   964     errorState.setObjectName("errorState");

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

   966     machine.setErrorState(&errorState);

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

   968 

   969     QState *initialBrokenState = new QState(&machine);

   970     initialBrokenState->setObjectName("initialBrokenState");

   971     machine.setInitialState(initialBrokenState);

   972     new QState(initialBrokenState);

   973 

   974     machine.start();

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

   976     QCoreApplication::processEvents();

   977 

   978     QCOMPARE(machine.isRunning(), false);

   979 }

   980 

   981 void tst_QStateMachine::restoreProperties()

   982 {

   983     QStateMachine machine;

   984     QCOMPARE(machine.globalRestorePolicy(), QStateMachine::DoNotRestoreProperties);

   985     machine.setGlobalRestorePolicy(QStateMachine::RestoreProperties);

   986 

   987     QObject *object = new QObject(&machine);

   988     object->setProperty("a", 1);

   989     object->setProperty("b", 2);

   990 

   991     QState *S1 = new QState();

   992     S1->setObjectName("S1");

   993     S1->assignProperty(object, "a", 3);

   994     machine.addState(S1);

   995 

   996     QState *S2 = new QState();

   997     S2->setObjectName("S2");

   998     S2->assignProperty(object, "b", 5);

   999     machine.addState(S2);

  1000 

  1001     QState *S3 = new QState();

  1002     S3->setObjectName("S3");

  1003     machine.addState(S3);

  1004 

  1005     QFinalState *S4 = new QFinalState();

  1006     machine.addState(S4);

  1007 

  1008     S1->addTransition(new EventTransition(QEvent::User, S2));

  1009     S2->addTransition(new EventTransition(QEvent::User, S3));

  1010     S3->addTransition(S4);

  1011 

  1012     machine.setInitialState(S1);

  1013     machine.start();

  1014     QCoreApplication::processEvents();

  1015 

  1016     QCOMPARE(object->property("a").toInt(), 3);

  1017     QCOMPARE(object->property("b").toInt(), 2);

  1018 

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

  1020     QCoreApplication::processEvents();

  1021 

  1022     QCOMPARE(object->property("a").toInt(), 1);

  1023     QCOMPARE(object->property("b").toInt(), 5);

  1024 

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

  1026     QCoreApplication::processEvents();

  1027 

  1028     QCOMPARE(object->property("a").toInt(), 1);

  1029     QCOMPARE(object->property("b").toInt(), 2);

  1030 }

  1031 

  1032 void tst_QStateMachine::rootState()

  1033 {

  1034     QStateMachine machine;

  1035     QCOMPARE(qobject_cast<QState*>(machine.parentState()), (QState*)0);

  1036     QCOMPARE(machine.machine(), (QStateMachine*)0);

  1037 

  1038     QState *s1 = new QState(&machine);

  1039     QCOMPARE(s1->parentState(), static_cast<QState*>(&machine));

  1040 

  1041     QState *s2 = new QState();

  1042     s2->setParent(&machine);

  1043     QCOMPARE(s2->parentState(), static_cast<QState*>(&machine));

  1044 }

  1045 

  1046 void tst_QStateMachine::addAndRemoveState()

  1047 {

  1048 #ifdef QT_BUILD_INTERNAL

  1049     QStateMachine machine;

  1050     QStatePrivate *root_d = QStatePrivate::get(&machine);

  1051     QCOMPARE(root_d->childStates().size(), 0);

  1052 

  1053     QTest::ignoreMessage(QtWarningMsg, "QStateMachine::addState: cannot add null state");

  1054     machine.addState(0);

  1055 

  1056     QState *s1 = new QState();

  1057     QCOMPARE(s1->parentState(), (QState*)0);

  1058     QCOMPARE(s1->machine(), (QStateMachine*)0);

  1059     machine.addState(s1);

  1060     QCOMPARE(s1->machine(), static_cast<QStateMachine*>(&machine));

  1061     QCOMPARE(s1->parentState(), static_cast<QState*>(&machine));

  1062     QCOMPARE(root_d->childStates().size(), 1);

  1063     QCOMPARE(root_d->childStates().at(0), (QAbstractState*)s1);

  1064 

  1065     QTest::ignoreMessage(QtWarningMsg, "QStateMachine::addState: state has already been added to this machine");

  1066     machine.addState(s1);

  1067 

  1068     QState *s2 = new QState();

  1069     QCOMPARE(s2->parentState(), (QState*)0);

  1070     machine.addState(s2);

  1071     QCOMPARE(s2->parentState(), static_cast<QState*>(&machine));

  1072     QCOMPARE(root_d->childStates().size(), 2);

  1073     QCOMPARE(root_d->childStates().at(0), (QAbstractState*)s1);

  1074     QCOMPARE(root_d->childStates().at(1), (QAbstractState*)s2);

  1075 

  1076     QTest::ignoreMessage(QtWarningMsg, "QStateMachine::addState: state has already been added to this machine");

  1077     machine.addState(s2);

  1078 

  1079     machine.removeState(s1);

  1080     QCOMPARE(s1->parentState(), (QState*)0);

  1081     QCOMPARE(root_d->childStates().size(), 1);

  1082     QCOMPARE(root_d->childStates().at(0), (QAbstractState*)s2);

  1083 

  1084     machine.removeState(s2);

  1085     QCOMPARE(s2->parentState(), (QState*)0);

  1086     QCOMPARE(root_d->childStates().size(), 0);

  1087 

  1088     QTest::ignoreMessage(QtWarningMsg, "QStateMachine::removeState: cannot remove null state");

  1089     machine.removeState(0);

  1090 

  1091     {

  1092         QStateMachine machine2;

  1093         {

  1094             QString warning;

  1095             warning.sprintf("QStateMachine::removeState: state %p's machine (%p) is different from this machine (%p)",

  1096                             &machine2, (void*)0, &machine);

  1097             QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));

  1098             machine.removeState(&machine2);

  1099         }

  1100         // ### check this behavior

  1101         machine.addState(&machine2);

  1102         QCOMPARE(machine2.parent(), (QObject*)&machine);

  1103     }

  1104 

  1105     delete s1;

  1106     delete s2;

  1107     // ### how to deal with this?

  1108     // machine.removeState(machine.errorState());

  1109 #endif

  1110 }

  1111 

  1112 void tst_QStateMachine::stateEntryAndExit()

  1113 {

  1114     // Two top-level states

  1115     {

  1116         QStateMachine machine;

  1117 

  1118         TestState *s1 = new TestState(&machine);

  1119         QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: cannot add transition to null state");

  1120         s1->addTransition((QAbstractState*)0);

  1121         QTest::ignoreMessage(QtWarningMsg, "QState::addTransition: cannot add null transition");

  1122         s1->addTransition((QAbstractTransition*)0);

  1123         QTest::ignoreMessage(QtWarningMsg, "QState::removeTransition: cannot remove null transition");

  1124         s1->removeTransition((QAbstractTransition*)0);

  1125 

  1126         TestState *s2 = new TestState(&machine);

  1127         QFinalState *s3 = new QFinalState(&machine);

  1128 

  1129         TestTransition *t = new TestTransition(s2);

  1130         QCOMPARE(t->machine(), (QStateMachine*)0);

  1131         QCOMPARE(t->sourceState(), (QState*)0);

  1132         QCOMPARE(t->targetState(), (QAbstractState*)s2);

  1133         QCOMPARE(t->targetStates().size(), 1);

  1134         QCOMPARE(t->targetStates().at(0), (QAbstractState*)s2);