qt/qtscxml/tests/auto/statemachine/tst_statemachine.cpp

Revision control

++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include <QtTest>
++ #include <QtTest/private/qpropertytesthelper_p.h>
++ #include <QObject>
++ #include <QXmlStreamReader>
++ #include <QtScxml/qscxmlcompiler.h>
++ #include <QtScxml/qscxmlstatemachine.h>
++ #include <QtScxml/qscxmlinvokableservice.h>
++ #include <QtScxml/private/qscxmlstatemachine_p.h>
++ #include <QtScxml/QScxmlNullDataModel>
++
++ #include "topmachine.h"
++
++ enum { SpyWaitTime = 8000 };
++
++ class tst_StateMachine: public QObject
++ {
++ Q_OBJECT
++
++ private Q_SLOTS:
++ void stateNames_data();
++ void stateNames();
++ void activeStateNames_data();
++ void activeStateNames();
++ void connections();
++ void historyState();
++ void onExit();
++ void eventOccurred();
++
++ void doneDotStateEvent();
++ void running();
++ void restart();
++
++ void invokeStateMachine();
++
++ void multipleInvokableServices(); // QTBUG-61484
++ void logWithoutExpr();
++
++ void foreachLoop();
++
++ void bindings();
++
++ void setTableDataUpdatesObjectNames();
++
++ void finalizeRunsOnDoneInvokeEvents();
++ void errorsFromNestedStatemachine(); // QTBUG-135396
++ };
++
++ void tst_StateMachine::errorsFromNestedStatemachine()
++ {
++ QScopedPointer<QScxmlStateMachine> machine(QScxmlStateMachine::fromFile(":/tst_statemachine/nestedinvoker.scxml"));
++ auto error = machine->parseErrors().front();
++ QCOMPARE(error.fileName(), "nestederror.scxml");
++ }
++
++ void tst_StateMachine::stateNames_data()
++ {
++ QTest::addColumn<QString>("scxmlFileName");
++ QTest::addColumn<bool>("compressed");
++ QTest::addColumn<QStringList>("expectedStates");
++
++ QTest::newRow("stateNames-compressed") << QString(":/tst_statemachine/statenames.scxml")
++ << true
++ << (QStringList() << QString("a1") << QString("a2") << QString("final"));
++ QTest::newRow("stateNames-notCompressed") << QString(":/tst_statemachine/statenames.scxml")
++ << false
++ << (QStringList() << QString("top") << QString("a") << QString("a1") << QString("a2") << QString("b") << QString("final"));
++ QTest::newRow("stateNamesNested-compressed") << QString(":/tst_statemachine/statenamesnested.scxml")
++ << true
++ << (QStringList() << QString("a") << QString("b"));
++ QTest::newRow("stateNamesNested-notCompressed") << QString(":/tst_statemachine/statenamesnested.scxml")
++ << false
++ << (QStringList() << QString("super_top") << QString("a") << QString("b"));
++
++ QTest::newRow("ids1") << QString(":/tst_statemachine/ids1.scxml")
++ << false
++ << (QStringList() << QString("foo.bar") << QString("foo-bar")
++ << QString("foo_bar") << QString("_"));
++ }
++
++ void tst_StateMachine::stateNames()
++ {
++ QFETCH(QString, scxmlFileName);
++ QFETCH(bool, compressed);
++ QFETCH(QStringList, expectedStates);
++
++ QScopedPointer<QScxmlStateMachine> stateMachine(QScxmlStateMachine::fromFile(scxmlFileName));
++ QVERIFY(!stateMachine.isNull());
++ QCOMPARE(stateMachine->parseErrors().size(), 0);
++
++ QCOMPARE(stateMachine->stateNames(compressed), expectedStates);
++ }
++
++ void tst_StateMachine::activeStateNames_data()
++ {
++ QTest::addColumn<QString>("scxmlFileName");
++ QTest::addColumn<bool>("compressed");
++ QTest::addColumn<QStringList>("expectedStates");
++
++ QTest::newRow("stateNames-compressed") << QString(":/tst_statemachine/statenames.scxml")
++ << true
++ << (QStringList() << QString("a1") << QString("final"));
++ QTest::newRow("stateNames-notCompressed") << QString(":/tst_statemachine/statenames.scxml")
++ << false
++ << (QStringList() << QString("top") << QString("a") << QString("a1") << QString("b") << QString("final"));
++ QTest::newRow("stateNamesNested-compressed") << QString(":/tst_statemachine/statenamesnested.scxml")
++ << true
++ << (QStringList() << QString("a") << QString("b"));
++ QTest::newRow("stateNamesNested-notCompressed") << QString(":/tst_statemachine/statenamesnested.scxml")
++ << false
++ << (QStringList() << QString("super_top") << QString("a") << QString("b"));
++ }
++
++ void tst_StateMachine::activeStateNames()
++ {
++ QFETCH(QString, scxmlFileName);
++ QFETCH(bool, compressed);
++ QFETCH(QStringList, expectedStates);
++
++ QScopedPointer<QScxmlStateMachine> stateMachine(QScxmlStateMachine::fromFile(scxmlFileName));
++ QVERIFY(!stateMachine.isNull());
++
++ QSignalSpy stableStateSpy(stateMachine.data(), SIGNAL(reachedStableState()));
++
++ stateMachine->start();
++
++ stableStateSpy.wait(5000);
++
++ QCOMPARE(stateMachine->activeStateNames(compressed), expectedStates);
++ }
++
++ class Receiver : public QObject {
++ Q_OBJECT
++ public slots:
++ void a(bool enabled)
++ {
++ aReached = aReached || enabled;
++ }
++
++ void b(bool enabled)
++ {
++ bReached = bReached || enabled;
++ }
++
++ void aEnter()
++ {
++ aEntered = true;
++ }
++
++ void aExit()
++ {
++ aExited = true;
++ }
++
++ public:
++ bool aReached = false;
++ bool bReached = false;
++ bool aEntered = false;
++ bool aExited = false;
++ };
++
++ void tst_StateMachine::connections()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/statenames.scxml")));
++ QVERIFY(!stateMachine.isNull());
++ Receiver receiver;
++
++ bool a1Reached = false;
++ bool finalReached = false;
++ QMetaObject::Connection a = stateMachine->connectToState("a", &receiver, &Receiver::a);
++ QVERIFY(a);
++ QMetaObject::Connection b = stateMachine->connectToState("b", &receiver, SLOT(b(bool)));
++ QVERIFY(b);
++ QMetaObject::Connection a1 = stateMachine->connectToState("a1", &receiver,
++ [&a1Reached](bool enabled) {
++ a1Reached = a1Reached || enabled;
++ });
++ QVERIFY(a1);
++ QMetaObject::Connection final = stateMachine->connectToState("final",
++ [&finalReached](bool enabled) {
++ finalReached = finalReached || enabled;
++ });
++ QVERIFY(final);
++
++ bool a1Entered = false;
++ bool a1Exited = false;
++ bool finalEntered = false;
++ bool finalExited = false;
++ typedef QScxmlStateMachine QXSM;
++
++ QMetaObject::Connection aEntry = stateMachine->connectToState(
++ "a", QXSM::onEntry(&receiver, &Receiver::aEnter));
++ QVERIFY(aEntry);
++ QMetaObject::Connection aExit = stateMachine->connectToState(
++ "a", QXSM::onExit(&receiver, &Receiver::aExit));
++ QVERIFY(aExit);
++ QMetaObject::Connection a1Entry = stateMachine->connectToState("a1", &receiver,
++ QXSM::onEntry([&a1Entered]() {
++ a1Entered = true;
++ }));
++ QVERIFY(a1Entry);
++ QMetaObject::Connection a1Exit = stateMachine->connectToState("a1", &receiver,
++ QXSM::onExit([&a1Exited]() {
++ a1Exited = true;
++ }));
++ QVERIFY(a1Exit);
++
++ QMetaObject::Connection finalEntry = stateMachine->connectToState(
++ "final", QXSM::onEntry([&finalEntered]() {
++ finalEntered = true;
++ }));
++ QVERIFY(finalEntry);
++
++ QMetaObject::Connection finalExit = stateMachine->connectToState(
++ "final", QXSM::onExit([&finalExited]() {
++ finalExited = true;
++ }));
++ QVERIFY(finalExit);
++
++ stateMachine->start();
++
++ QTRY_VERIFY(a1Reached);
++ QTRY_VERIFY(finalReached);
++ QTRY_VERIFY(receiver.aReached);
++ QTRY_VERIFY(receiver.bReached);
++
++ QVERIFY(disconnect(a));
++ QVERIFY(disconnect(b));
++ QVERIFY(disconnect(a1));
++ QVERIFY(disconnect(final));
++
++ #if defined(__cpp_return_type_deduction) && __cpp_return_type_deduction == 201304
++ QVERIFY(receiver.aEntered);
++ QVERIFY(!receiver.aExited);
++ QVERIFY(a1Entered);
++ QVERIFY(!a1Exited);
++ QVERIFY(finalEntered);
++ QVERIFY(!finalExited);
++
++ QVERIFY(disconnect(aEntry));
++ QVERIFY(disconnect(aExit));
++ QVERIFY(disconnect(a1Entry));
++ QVERIFY(disconnect(a1Exit));
++ QVERIFY(disconnect(finalEntry));
++ QVERIFY(disconnect(finalExit));
++ #endif
++ }
++
++ void tst_StateMachine::historyState()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/historystate.scxml")));
++ QVERIFY(!stateMachine.isNull());
++
++ bool state2Reached = false;
++ QMetaObject::Connection state2Connection = stateMachine->connectToState("State2",
++ [&state2Reached](bool enabled) {
++ state2Reached = state2Reached || enabled;
++ });
++ QVERIFY(state2Connection);
++
++ stateMachine->start();
++
++ QTRY_VERIFY(state2Reached);
++ }
++
++ void tst_StateMachine::onExit()
++ {
++ #if defined(__cpp_return_type_deduction) && __cpp_return_type_deduction == 201304
++ // Test onExit being actually called
++
++ typedef QScxmlStateMachine QXSM;
++ QScopedPointer<QXSM> stateMachine(QXSM::fromFile(QString(":/tst_statemachine/eventoccurred.scxml")));
++
++ Receiver receiver;
++ bool aExited1 = false;
++
++ stateMachine->connectToState("a", QXSM::onExit([&aExited1]() { aExited1 = true; }));
++ stateMachine->connectToState("a", QXSM::onExit(&receiver, &Receiver::aExit));
++ stateMachine->connectToState("a", QXSM::onExit(&receiver, "aEnter"));
++ {
++ // Should not crash
++ Receiver receiver2;
++ stateMachine->connectToState("a", QXSM::onEntry(&receiver2, &Receiver::aEnter));
++ stateMachine->connectToState("a", QXSM::onEntry(&receiver2, "aExit"));
++ stateMachine->connectToState("a", QXSM::onExit(&receiver2, &Receiver::aExit));
++ stateMachine->connectToState("a", QXSM::onExit(&receiver2, "aEnter"));
++ }
++
++ stateMachine->start();
++ QTRY_VERIFY(receiver.aEntered);
++ QTRY_VERIFY(receiver.aExited);
++ QTRY_VERIFY(aExited1);
++ #endif
++ }
++
++ bool hasChildEventRouters(QScxmlStateMachine *stateMachine)
++ {
++ // Cast to QObject, to avoid ambigous "children" member.
++ const QObject &parentRouter = QScxmlStateMachinePrivate::get(stateMachine)->m_router;
++ return !parentRouter.children().isEmpty();
++ }
++
++ void tst_StateMachine::eventOccurred()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(QScxmlStateMachine::fromFile(QString(":/tst_statemachine/eventoccurred.scxml")));
++ QVERIFY(!stateMachine.isNull());
++
++ qRegisterMetaType<QScxmlEvent>();
++ QSignalSpy finishedSpy(stateMachine.data(), SIGNAL(finished()));
++
++ int events = 0;
++ auto con1 = stateMachine->connectToEvent("internalEvent2", [&events](const QScxmlEvent &event) {
++ QCOMPARE(++events, 1);
++ QCOMPARE(event.name(), QString("internalEvent2"));
++ QCOMPARE(event.eventType(), QScxmlEvent::ExternalEvent);
++ });
++ QVERIFY(con1);
++
++ auto con2 = stateMachine->connectToEvent("externalEvent", [&events](const QScxmlEvent &event) {
++ QCOMPARE(++events, 2);
++ QCOMPARE(event.name(), QString("externalEvent"));
++ QCOMPARE(event.eventType(), QScxmlEvent::ExternalEvent);
++ });
++ QVERIFY(con2);
++
++ auto con3 = stateMachine->connectToEvent("timeout", [&events](const QScxmlEvent &event) {
++ QCOMPARE(++events, 3);
++ QCOMPARE(event.name(), QString("timeout"));
++ QCOMPARE(event.eventType(), QScxmlEvent::ExternalEvent);
++ });
++ QVERIFY(con3);
++
++ auto con4 = stateMachine->connectToEvent("done.*", [&events](const QScxmlEvent &event) {
++ QCOMPARE(++events, 4);
++ QCOMPARE(event.name(), QString("done.state.top"));
++ QCOMPARE(event.eventType(), QScxmlEvent::ExternalEvent);
++ });
++ QVERIFY(con4);
++
++ auto con5 = stateMachine->connectToEvent("done.state", [&events](const QScxmlEvent &event) {
++ QCOMPARE(++events, 5);
++ QCOMPARE(event.name(), QString("done.state.top"));
++ QCOMPARE(event.eventType(), QScxmlEvent::ExternalEvent);
++ });
++ QVERIFY(con5);
++
++ auto con6 = stateMachine->connectToEvent("done.state.top", [&events](const QScxmlEvent &event) {
++ QCOMPARE(++events, 6);
++ QCOMPARE(event.name(), QString("done.state.top"));
++ QCOMPARE(event.eventType(), QScxmlEvent::ExternalEvent);
++ });
++ QVERIFY(con6);
++
++ stateMachine->start();
++
++ finishedSpy.wait(5000);
++ QCOMPARE(events, 6);
++
++ QVERIFY(disconnect(con1));
++ QVERIFY(disconnect(con2));
++ QVERIFY(disconnect(con3));
++ QVERIFY(disconnect(con4));
++ QVERIFY(disconnect(con5));
++ QVERIFY(disconnect(con6));
++
++ QTRY_VERIFY(!hasChildEventRouters(stateMachine.data()));
++ }
++
++ void tst_StateMachine::doneDotStateEvent()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(QScxmlStateMachine::fromFile(QString(":/tst_statemachine/stateDotDoneEvent.scxml")));
++ QVERIFY(!stateMachine.isNull());
++
++ QSignalSpy finishedSpy(stateMachine.data(), SIGNAL(finished()));
++
++ stateMachine->start();
++ finishedSpy.wait(5000);
++ QCOMPARE(finishedSpy.size(), 1);
++ QCOMPARE(stateMachine->activeStateNames(true).size(), 1);
++ QVERIFY(stateMachine->activeStateNames(true).contains(QLatin1String("success")));
++ }
++
++ void tst_StateMachine::running()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/statenames.scxml")));
++ QVERIFY(!stateMachine.isNull());
++
++ QSignalSpy runningChangedSpy(stateMachine.data(), SIGNAL(runningChanged(bool)));
++
++ QCOMPARE(stateMachine->isRunning(), false);
++
++ stateMachine->start();
++
++ QCOMPARE(runningChangedSpy.size(), 1);
++ QCOMPARE(stateMachine->isRunning(), true);
++
++ stateMachine->stop();
++
++ QCOMPARE(runningChangedSpy.size(), 2);
++ QCOMPARE(stateMachine->isRunning(), false);
++ }
++
++ void tst_StateMachine::restart()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/stateDotDoneEvent.scxml")));
++ QVERIFY(!stateMachine.isNull());
++
++ QSignalSpy finishedSpy(stateMachine.data(), SIGNAL(finished()));
++
++ stateMachine->start();
++ finishedSpy.wait(5000);
++ QCOMPARE(finishedSpy.size(), 1);
++ QCOMPARE(stateMachine->activeStateNames(true).size(), 1);
++ QVERIFY(stateMachine->activeStateNames(true).contains(QLatin1String("success")));
++
++ QTest::ignoreMessage(QtWarningMsg, QRegularExpression("(.*)Can't start finished machine"));
++ stateMachine->start();
++ }
++
++ void tst_StateMachine::invokeStateMachine()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/invoke.scxml")));
++ QVERIFY(!stateMachine.isNull());
++
++ stateMachine->start();
++ QCOMPARE(stateMachine->isRunning(), true);
++ QTRY_VERIFY(stateMachine->activeStateNames().contains(QString("anyplace")));
++
++ QList<QScxmlInvokableService *> services = stateMachine->invokedServices();
++ QCOMPARE(services.size(), 1);
++ QVariant subMachineVariant = services[0]->property("stateMachine");
++ QVERIFY(subMachineVariant.isValid());
++ QScxmlStateMachine *subMachine = qvariant_cast<QScxmlStateMachine *>(subMachineVariant);
++ QVERIFY(subMachine);
++ QTRY_VERIFY(subMachine->activeStateNames().contains("here"));
++ }
++
++ void tst_StateMachine::multipleInvokableServices()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/multipleinvokableservices.scxml")));
++ QVERIFY(!stateMachine.isNull());
++
++ QSignalSpy finishedSpy(stateMachine.data(), SIGNAL(finished()));
++ stateMachine->start();
++ QCOMPARE(stateMachine->isRunning(), true);
++
++ finishedSpy.wait(5000);
++ QCOMPARE(finishedSpy.size(), 1);
++ QCOMPARE(stateMachine->activeStateNames(true).size(), 1);
++ QVERIFY(stateMachine->activeStateNames(true).contains(QLatin1String("success")));
++ }
++
++ void tst_StateMachine::logWithoutExpr()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/emptylog.scxml")));
++ QVERIFY(!stateMachine.isNull());
++ QTest::ignoreMessage(QtDebugMsg, "\"Hi2\" : \"\"");
++ stateMachine->start();
++ QSignalSpy logSpy(stateMachine.data(), SIGNAL(log(QString,QString)));
++ QTRY_COMPARE(logSpy.size(), 1);
++ }
++
++ void tst_StateMachine::foreachLoop()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/foreach.scxml")));
++ QVERIFY(!stateMachine.isNull());
++
++ qRegisterMetaType<QScxmlEvent>();
++ QSignalSpy finishedSpy(stateMachine.data(), SIGNAL(finished()));
++
++ int events1 = 0;
++ int events2 = 0;
++ int events3 = 0;
++
++ auto con1 = stateMachine->connectToEvent("internalEvent1", [&events1](const QScxmlEvent &event) {
++ ++events1;
++ QCOMPARE(event.name(), QString("internalEvent1"));
++ });
++ QVERIFY(con1);
++
++ auto con2 = stateMachine->connectToEvent("internalEvent2", [&events2](const QScxmlEvent &event) {
++ ++events2;
++ QCOMPARE(event.name(), QString("internalEvent2"));
++ });
++ QVERIFY(con2);
++
++ auto con3 = stateMachine->connectToEvent("internalEvent3", [&events3](const QScxmlEvent &event) {
++ ++events3;
++ QCOMPARE(event.name(), QString("internalEvent3"));
++ });
++ QVERIFY(con3);
++
++ stateMachine->start();
++
++ finishedSpy.wait(5000);
++ QCOMPARE(events1, 3);
++ QCOMPARE(events2, 3);
++ QCOMPARE(events3, 3);
++ }
++
++ void tst_StateMachine::bindings()
++ {
++ // -- QScxmlStateMachine::initialized
++ std::unique_ptr<QScxmlStateMachine> stateMachine1(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/invoke.scxml")));
++ QVERIFY(stateMachine1.get());
++ QTestPrivate::testReadOnlyPropertyBasics<QScxmlStateMachine, bool>(
++ *stateMachine1, false, true, "initialized", [&](){ stateMachine1.get()->start(); });
++ if (QTest::currentTestFailed()) {
++ qWarning() << "QScxmlStateMachine::initialized bindable test failed.";
++ return;
++ }
++
++ using StateMachinePtr = std::unique_ptr<QScxmlStateMachine>;
++
++ // -- QScxmlStateMachine::initialValues
++ QVariantMap map1{{"map", 1}};
++ QVariantMap map2{{"map", 2}};
++ QTestPrivate::testReadWritePropertyBasics<QScxmlStateMachine, QVariantMap>(
++ *stateMachine1, map1, map2, "initialValues",
++ []() {
++ return StateMachinePtr{QScxmlStateMachine::fromFile(QString("not_a_real_file"))};
++ });
++ if (QTest::currentTestFailed()) {
++ qWarning() << "QScxmlStateMachine::initialValues bindable test failed.";
++ return;
++ }
++
++ // -- QScxmlStateMachine::loader
++ class MockLoader: public QScxmlCompiler::Loader
++ {
++ public:
++ QByteArray load(const QString&, const QString&, QStringList*) override { return QByteArray(); }
++ };
++ MockLoader loader1;
++ MockLoader loader2;
++ QTestPrivate::testReadWritePropertyBasics<QScxmlStateMachine, QScxmlCompiler::Loader*>(
++ *stateMachine1, &loader1, &loader2, "loader",
++ []() {
++ return StateMachinePtr{QScxmlStateMachine::fromFile(QString("not_a_real_file"))};
++ });
++ if (QTest::currentTestFailed()) {
++ qWarning() << "QScxmlStateMachine::loader bindable test failed.";
++ return;
++ }
++
++ // -- QScxmlStateMachine::dataModel
++ // Use non-existent file below, as valid file would initialize the model
++ std::unique_ptr<QScxmlStateMachine> stateMachine2(
++ QScxmlStateMachine::fromFile(QString("not_a_real_file")));
++ std::unique_ptr<QScxmlStateMachine> stateMachine3(
++ QScxmlStateMachine::fromFile(QString("not_a_real_file")));
++ QScxmlNullDataModel model1;
++ // data can only change once
++ QTestPrivate::testWriteOncePropertyBasics<QScxmlStateMachine, QScxmlDataModel*>(
++ *stateMachine2, nullptr, &model1, "dataModel", true,
++ []() {
++ return StateMachinePtr{QScxmlStateMachine::fromFile(QString("not_a_real_file"))};
++ });
++ if (QTest::currentTestFailed()) {
++ qWarning() << "QScxmlStateMachine::dataModel bindable test failed.";
++ return;
++ }
++
++ // -- QScxmlStateMachine::tableData
++ // Use the statemachine to generate the tableData for testing
++ std::unique_ptr<QScxmlStateMachine> stateMachine4(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/invoke.scxml")));
++ QTestPrivate::testReadWritePropertyBasics<QScxmlStateMachine, QScxmlTableData*>(
++ *stateMachine2, stateMachine1.get()->tableData(), stateMachine4.get()->tableData(),
++ "tableData",
++ []() {
++ return StateMachinePtr{QScxmlStateMachine::fromFile(QString("not_a_real_file"))};
++ });
++ if (QTest::currentTestFailed()) {
++ qWarning() << "QScxmlStateMachine::tableData bindable test failed.";
++ return;
++ }
++
++ // -- QScxmlStateMachine::invokedServices
++ // Test executes statemachine and observes as the invoked services change
++ TopMachine topSm;
++ QSignalSpy invokedSpy(&topSm, SIGNAL(invokedServicesChanged(QList<QScxmlInvokableService*>)));
++ QCOMPARE(topSm.invokedServices().size(), 0);
++ // at some point during the topSm execution there are 3 invoked services
++ topSm.start();
++ QTRY_COMPARE(topSm.invokedServices().size(), 3);
++ QCOMPARE(invokedSpy.size(), 1);
++ // after completion invoked services drop back to 0
++ QTRY_COMPARE(topSm.isRunning(), false);
++ QCOMPARE(topSm.invokedServices().size(), 0);
++ QCOMPARE(invokedSpy.size(), 2);
++ // bind *to* the invokedservices property and check that we observe same changes
++ // during the topSm execution
++ QProperty<qsizetype> invokedServicesObserver;
++ invokedServicesObserver.setBinding([&](){ return topSm.invokedServices().size(); });
++ QCOMPARE(invokedServicesObserver, 0);
++ topSm.start();
++ QTRY_COMPARE(invokedServicesObserver, 3);
++ QCOMPARE(topSm.invokedServices().size(), 3);
++ QCOMPARE(invokedSpy.size(), 3);
++
++ // -- QScxmlDataModel::stateMachine
++ QScxmlNullDataModel dataModel1;
++ std::unique_ptr<QScxmlStateMachine> stateMachine5(
++ QScxmlStateMachine::fromFile(QString("not_a_real_file")));
++ // data can only change once
++ QTestPrivate::testWriteOncePropertyBasics<QScxmlNullDataModel, QScxmlStateMachine*>(
++ dataModel1, nullptr, stateMachine5.get(), "stateMachine");
++ if (QTest::currentTestFailed()) {
++ qWarning() << "QScxmlDataModel::stateMachine bindable test failed.";
++ return;
++ }
++ }
++
++ void tst_StateMachine::setTableDataUpdatesObjectNames()
++ {
++ std::unique_ptr<QScxmlStateMachine> stateMachine1(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/emptylog.scxml")));
++ const QString sm1ObjectName = stateMachine1->objectName();
++ std::unique_ptr<QScxmlStateMachine> stateMachine2(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/eventoccurred.scxml")));
++ const QString sm2ObjectName = stateMachine2->objectName();
++ QCOMPARE_NE(sm1ObjectName, sm2ObjectName);
++
++ std::unique_ptr<QScxmlStateMachine> sm(
++ QScxmlStateMachine::fromFile(QString("not_a_real_file")));
++ QVERIFY(sm->objectName().isEmpty());
++ // no name set, so update object name
++ sm->setTableData(stateMachine1->tableData());
++ QCOMPARE_EQ(sm->objectName(), sm1ObjectName);
++
++ // object name already set, so do not update
++ sm->setTableData(stateMachine2->tableData());
++ QCOMPARE_EQ(sm->objectName(), sm1ObjectName); // did not change
++ }
++
++ void tst_StateMachine::finalizeRunsOnDoneInvokeEvents()
++ {
++ QScopedPointer<QScxmlStateMachine> stateMachine(
++ QScxmlStateMachine::fromFile(QString(":/tst_statemachine/finalizeOnDoneInvokeEvent.scxml")));
++ QVERIFY(!stateMachine.isNull());
++
++ QSignalSpy logSpy(stateMachine.data(), SIGNAL(log(QString,QString)));
++
++ stateMachine->start();
++
++ QTRY_COMPARE(logSpy.size(), 1);
++
++ QList<QVariant> arguments = logSpy.takeFirst();
++ QCOMPARE(arguments.at(0).toString(), QString(u"finalize"));
++ QVERIFY(arguments.at(1).toString().startsWith("done.invoke.s0"));
++ }
++
++ QTEST_MAIN(tst_StateMachine)
++
++ #include "tst_statemachine.moc"