Revision control
++ // Copyright (C) 2021 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include "../../shared/util.h"
++
++ #include <QtTest>
++ #include <QtTest/private/qpropertytesthelper_p.h>
++ #include <QtScxml/QScxmlStateMachine>
++ #include <QtScxml/QScxmlNullDataModel>
++ #include <QtScxmlQml/private/eventconnection_p.h>
++ #include <QtScxmlQml/private/invokedservices_p.h>
++ #include <QtScxmlQml/private/statemachineloader_p.h>
++ #include "topmachine.h"
++ #include <functional>
++ #include <QtQml/QQmlEngine>
++ #include <QtQml/QQmlComponent>
++ #include <memory>
++
++ class tst_scxmlqmlcpp : public QQmlDataTest
++ {
++ Q_OBJECT
++
++ private slots:
++ void initTestCase() override;
++
++ void eventConnectionStateMachineBinding();
++ void eventConnectionEventsBinding();
++
++ void invokedServicesStateMachineBinding();
++ void invokedServicesChildrenBinding();
++
++ void stateMachineLoaderInitialValuesBinding();
++ void stateMachineLoaderSourceStateMachineBinding();
++ void stateMachineLoaderDatamodelBinding();
++
++ private:
++ QScxmlEventConnection m_eventConnection;
++ QScxmlInvokedServices m_invokedServices;
++ QScxmlStateMachineLoader m_stateMachineLoader;
++ std::unique_ptr<QScxmlStateMachine> m_stateMachine1;
++ std::unique_ptr<QScxmlStateMachine> m_stateMachine2;
++ };
++
++ void tst_scxmlqmlcpp::initTestCase()
++ {
++ QQmlDataTest::initTestCase();
++ m_stateMachine1.reset(QScxmlStateMachine::fromFile("no_real_file_needed"));
++ m_stateMachine2.reset(QScxmlStateMachine::fromFile("no_real_file_needed"));
++ }
++
++ void tst_scxmlqmlcpp::eventConnectionStateMachineBinding()
++ {
++ QCOMPARE(m_eventConnection.bindableStateMachine().value(), nullptr);
++ QTestPrivate::testReadWritePropertyBasics<QScxmlEventConnection, QScxmlStateMachine*>(
++ m_eventConnection, m_stateMachine1.get(), m_stateMachine2.get(), "stateMachine");
++ m_eventConnection.setStateMachine(nullptr); // tidy up
++ }
++
++ void tst_scxmlqmlcpp::eventConnectionEventsBinding()
++ {
++ QStringList eventList1{{"event1"},{"event2"}};
++ QStringList eventList2{{"event3"},{"event4"}};
++ QCOMPARE(m_eventConnection.events(), QStringList());
++ QTestPrivate::testReadWritePropertyBasics<QScxmlEventConnection, QStringList>(
++ m_eventConnection, eventList1, eventList2, "events");
++ m_eventConnection.setEvents(QStringList()); // tidy up
++ }
++
++ void tst_scxmlqmlcpp::invokedServicesStateMachineBinding()
++ {
++ QCOMPARE(m_invokedServices.stateMachine(), nullptr);
++ QTestPrivate::testReadWritePropertyBasics<QScxmlInvokedServices, QScxmlStateMachine*>(
++ m_invokedServices, m_stateMachine1.get(), m_stateMachine2.get(), "stateMachine");
++ m_invokedServices.setStateMachine(nullptr); // tidy up
++ }
++
++ void tst_scxmlqmlcpp::invokedServicesChildrenBinding()
++ {
++ TopMachine topSm;
++ QScxmlInvokedServices invokedServices;
++ invokedServices.setStateMachine(&topSm);
++ QCOMPARE(invokedServices.children().size(), 0);
++ QCOMPARE(topSm.invokedServices().size(), 0);
++ // at some point during the topSm execution there are 3 invoked services
++ // of the same name ('3' filters out as '1' at QML binding)
++ topSm.start();
++ QTRY_COMPARE(topSm.invokedServices().size(), 3);
++ QCOMPARE(invokedServices.children().size(), 1);
++ // after completion invoked services drop back to 0
++ QTRY_COMPARE(topSm.invokedServices().size(), 0);
++ QCOMPARE(invokedServices.children().size(), 0);
++ // bind *to* the invokedservices property and check that we observe same changes
++ // during the topSm execution
++ QProperty<qsizetype> serviceCounter;
++ serviceCounter.setBinding([&](){ return invokedServices.children().size(); });
++ QCOMPARE(serviceCounter, 0);
++ topSm.start();
++ QTRY_COMPARE(serviceCounter, 1);
++ QCOMPARE(topSm.invokedServices().size(), 3);
++ }
++
++ void tst_scxmlqmlcpp::stateMachineLoaderInitialValuesBinding()
++ {
++ QVariantMap values1{{"key1","value1"}, {"key2","value2"}};
++ QVariantMap values2{{"key3","value3"}, {"key4","value4"}};
++ QTestPrivate::testReadWritePropertyBasics<QScxmlStateMachineLoader, QVariantMap>(
++ m_stateMachineLoader, values1, values2, "initialValues");
++ m_stateMachineLoader.setInitialValues(QVariantMap()); // tidy up
++ }
++
++ void tst_scxmlqmlcpp::stateMachineLoaderSourceStateMachineBinding()
++ {
++ // Test source and stateMachine together as they interact with each other
++
++ QUrl source1(testFileUrl("submachineA.scxml"));
++ QUrl source2(testFileUrl("submachineB.scxml"));
++ // The 'setSource' of the statemachineloader assumes a valid qml context
++ QQmlEngine engine;
++ const QUrl smlUrl = testFileUrl("stateMachineLoader.qml");
++ QQmlComponent component(&engine, smlUrl);
++ QVERIFY2(component.isReady(), qPrintable(component.errorString()));
++ std::unique_ptr<QObject> root(component.create());
++ QScxmlStateMachineLoader *sml =
++ qobject_cast<QScxmlStateMachineLoader*>(root->findChild<QObject*>("sml"));
++ QVERIFY(sml != nullptr);
++
++ QQmlComponent otherComponent(&engine, testFileUrl("smlHelper.qml"));
++
++ // -- StateMachineLoader::source
++ QTestPrivate::testReadWritePropertyBasics<QScxmlStateMachineLoader, QUrl>(
++ *sml, source1, source2, "source",
++ [&otherComponent]() {
++ return std::unique_ptr<QScxmlStateMachineLoader>(
++ qobject_cast<QScxmlStateMachineLoader*>(otherComponent.create()));
++ });
++ if (QTest::currentTestFailed()) {
++ qWarning() << "QScxmlStateMachineLoader::source property testing failed";
++ return;
++ }
++
++ // -- StateMachineLoader::stateMachine
++ // The statemachine can be set indirectly by setting the 'source'
++ QSignalSpy smSpy(sml, &QScxmlStateMachineLoader::stateMachineChanged);
++ QUrl sourceNonexistent(testFileUrl("file_doesnt_exist.scxml"));
++ QUrl sourceBroken(testFileUrl("brokenstatemachine.scxml"));
++
++ QVERIFY(sml->stateMachine() != nullptr);
++ QTest::ignoreMessage(QtWarningMsg, QRegularExpression(
++ smlUrl.toString() + ":5:5: QML StateMachineLoader: " +
++ "Cannot open '" + testFile("file_doesnt_exist.scxml") +
++ "' for reading: .*"));
++ sml->setSource(sourceNonexistent);
++ QVERIFY(sml->stateMachine() == nullptr);
++ QCOMPARE(smSpy.size(), 1);
++
++ QString sourceBrokenNoScheme;
++ if (sourceBroken.scheme() == QStringLiteral("qrc"))
++ sourceBrokenNoScheme = QStringLiteral(":") + sourceBroken.path();
++ else
++ sourceBrokenNoScheme = sourceBroken.toLocalFile();
++ QTest::ignoreMessage(QtWarningMsg,
++ qPrintable(smlUrl.toString() + ":5:5: QML StateMachineLoader: " +
++ sourceBrokenNoScheme + ":12:1: error: initial state 'working' " +
++ "not found for <scxml> element"));
++
++ QTest::ignoreMessage(QtWarningMsg,
++ "SCXML document has errors");
++ QTest::ignoreMessage(QtWarningMsg,
++ qPrintable(smlUrl.toString() + ":5:5: QML StateMachineLoader: Something " +
++ "went wrong while parsing '" + sourceBroken.toString() + "':\n"));
++ sml->setSource(sourceBroken);
++ QVERIFY(sml->stateMachine() == nullptr);
++ QCOMPARE(smSpy.size(), 1);
++
++ QProperty<bool> hasStateMachine([&](){ return sml->stateMachine() ? true : false; });
++ QVERIFY(hasStateMachine == false);
++ sml->setSource(source1);
++ QCOMPARE(smSpy.size(), 2);
++ QVERIFY(hasStateMachine == true);
++ }
++
++ void tst_scxmlqmlcpp::stateMachineLoaderDatamodelBinding()
++ {
++ QScxmlNullDataModel model1;
++ QScxmlNullDataModel model2;
++ QTestPrivate::testReadWritePropertyBasics<QScxmlStateMachineLoader,QScxmlDataModel*>
++ (m_stateMachineLoader, &model1, &model2, "dataModel");
++ m_stateMachineLoader.setDataModel(nullptr); // tidy up
++ }
++
++ QTEST_MAIN(tst_scxmlqmlcpp)
++ #include "tst_scxmlqmlcpp.moc"