tests/main.cpp

 // Copyright (C) 2024 The Qt Company Ltd.
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
-#include <QGuiApplication>
+#include <QApplication>
 #include <QTemporaryFile>
 #include <QTest>
 
+#include "tst_dsmanager.h"
+#include "tst_projectmanager.h"
 #include "tst_settings.h"
 
-#define DEBUG_LINE qDebug() << "Debugline:" << __LINE__
+#define DEBUG_LINE qDebug() << "Debug (" << __LINE__ << "):"
 
 int main(int argc, char *argv[])
 {
-    QGuiApplication app(argc, argv);
+    qputenv("QML_COMPAT_RESOLVE_URLS_ON_ASSIGNMENT", "1");
+    QApplication app(argc, argv);
 
     QStringList initialArgs = app.arguments();
     DEBUG_LINE << "Arguments:" << initialArgs;
@@ -33,14 +36,14 @@ int main(int argc, char *argv[])
     }
 
     if (outputFileName.isEmpty()) {
-        qDebug() << "Output file name not provided. Using the default name: output.junitxml";
+        DEBUG_LINE << "Output file name not provided. Using the default name: output.junitxml";
         outputFileName = "output.junitxml";
     }
 
     QFile outputFile{outputFileName};
-    if (!outputFile.open(QIODevice::Append)) {
+    if (!outputFile.open(QIODevice::Truncate | QIODevice::WriteOnly)) {
         DEBUG_LINE << "Failed to open the output file";
-        return 1;
+        return -1;
     }
 
     int status = 0;
@@ -48,8 +51,11 @@ int main(int argc, char *argv[])
         // temporary file to store the individual test results.
         // we'll append the results to the output file.
         QTemporaryFile file;
-        file.open();
-        DEBUG_LINE << "Temporary file:" << file.fileName();
+        if (!file.open()) {
+            DEBUG_LINE << "Failed to open the temporary file";
+            status = -1;
+            return;
+        }
 
         QStringList args{"-o", QString(file.fileName()).append(",junitxml")};
         args.prepend(appName);
@@ -60,15 +66,24 @@ int main(int argc, char *argv[])
 
         // append the test results to the output file
         file.readLine(); // skip the first line because it's the xml header
-        outputFile.write(file.readAll());
+        const int rV = outputFile.write(file.readAll());
+        if (rV == -1) {
+            DEBUG_LINE << "Failed to write the test results to the output file";
+            status = -1;
+            return;
+        }
     };
 
     outputFile.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
     outputFile.write("<testsuites>\n");
 
     runTest(new TestSettings);
+    runTest(new TestDesignStudioManager);
+    runTest(new TestProjectManager);
 
     outputFile.write("</testsuites>\n");
+    outputFile.flush();
+    outputFile.close();
 
     DEBUG_LINE << "Test suite finished with status:" << status;
     return status;

tests/mock_ds.cpp

+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "mock_ds.h"
+
+#include <QJsonParseError>
+#include <QJsonObject>
+#include <QJsonDocument>
+
+namespace PackageToDevice {
+using namespace Qt::Literals;
+constexpr auto designStudioReady = "designStudioReady"_L1;
+constexpr auto projectData = "projectData"_L1;
+constexpr auto stopRunningProject = "stopRunningProject"_L1;
+}; // namespace PackageToDevice
+
+namespace PackageFromDevice {
+using namespace Qt::Literals;
+constexpr auto deviceInfo = "deviceInfo"_L1;
+constexpr auto projectReceivingProgress = "projectReceivingProgress"_L1;
+constexpr auto projectStarting = "projectStarting"_L1;
+constexpr auto projectStarted = "projectRunning"_L1;
+constexpr auto projectStopped = "projectStopped"_L1;
+constexpr auto projectLogs = "projectLogs"_L1;
+}; // namespace PackageFromDevice
+
+MockDS::MockDS(const QString dsID,
+               const QString &serverAddr,
+               const QString &serverName,
+               QObject *parent)
+    : QObject(parent)
+    , m_dsID(dsID)
+    , m_serverAddr(serverAddr)
+{
+      m_socket.reset(new QWebSocket(serverName, QWebSocketProtocol::VersionLatest, this));
+      QObject::connect(m_socket.data(),
+                       &QWebSocket::textMessageReceived,
+                       this,
+                       &MockDS::textMessageReceived);
+      connect();
+}
+
+MockDS::~MockDS()
+{
+    m_socket->close();
+}
+
+void MockDS::connect()
+{
+    m_socket->open(QUrl(m_serverAddr));
+}
+
+void MockDS::disconnect()
+{
+    m_socket->close();
+    m_socket->abort();
+}
+
+bool MockDS::isConnected() const
+{
+    return m_socket->isValid();
+}
+
+bool MockDS::sendTextMessage(const QLatin1String &dataType, const QJsonValue &data)
+{
+    if (!isConnected())
+        return false;
+
+    QJsonObject message;
+    message["dataType"] = dataType;
+    message["data"] = data;
+    const QString jsonMessage = QString::fromLatin1(
+        QJsonDocument(message).toJson(QJsonDocument::Compact));
+    m_socket->sendTextMessage(jsonMessage);
+
+    return true;
+}
+
+bool MockDS::sendDesignStudioReady()
+{
+    QJsonObject data;
+    data["designStudioID"] = m_dsID;
+    data["commVersion"] = 1;
+    return sendTextMessage(PackageToDevice::designStudioReady, data);
+}
+
+bool MockDS::sendProjectData(const QByteArray &data, const QString &qtVersion)
+{
+    QJsonObject projectInfo;
+    projectInfo["projectSize"] = data.size();
+    projectInfo["qtVersion"] = qtVersion;
+
+    const bool rV = sendTextMessage(PackageToDevice::projectData, projectInfo);
+    if (!rV)
+        return false;
+
+    const int dataSent = m_socket->sendBinaryMessage(data);
+    return dataSent == data.size();
+}
+
+bool MockDS::sendProjectStopped()
+{
+    return sendTextMessage(PackageToDevice::stopRunningProject, {});
+}
+
+void MockDS::textMessageReceived(const QString &message){
+    qDebug () << "Message received: " << message;
+    QJsonParseError jsonError;
+    const QJsonDocument jsonDoc = QJsonDocument::fromJson(message.toLatin1(), &jsonError);
+
+    const QJsonObject jsonObj = jsonDoc.object();
+    const QString dataType = jsonObj.value("dataType").toString();
+    if (dataType == PackageFromDevice::deviceInfo) {
+        QJsonObject deviceInfo = jsonObj.value("data").toObject();
+        emit deviceInfoReady();
+    } else if (dataType == PackageFromDevice::projectStarted) {
+        emit projectStarted();
+    } else if (dataType == PackageFromDevice::projectStopped) {
+        emit projectStopped();
+    } else if (dataType == PackageFromDevice::projectLogs) {
+        const QString logs = jsonObj.value("data").toString();
+        emit projectLogsReceived(logs);
+    } else if (dataType == PackageFromDevice::projectStarting) {
+        emit projectStarting();
+    } else if (dataType == PackageFromDevice::projectReceivingProgress) {
+        const int progress = jsonObj.value("data").toInt();
+        emit projectSendingProgress(progress);
+    }
+}

tests/mock_ds.h

+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#pragma once
+
+#include <QWebSocket>
+
+/**
+ * @brief This is a mock class to simulate the Design Studio connection.
+ * This one acts like a client and the DesignStudioManager acts like a server.
+ * This can be used to test the data coming from the Design Studio or the vice versa.
+ */
+class MockDS : public QObject
+{
+    Q_OBJECT
+public:
+    MockDS(const QString dsID, const QString &serverAddr, const QString &serverName, QObject *parent = nullptr);
+    ~MockDS();
+
+    void connect();
+    void disconnect();
+    bool isConnected() const;
+    bool sendDesignStudioReady();
+    bool sendProjectData(const QByteArray &data, const QString &qtVersion);
+    bool sendProjectStopped();
+
+private:
+    QScopedPointer<QWebSocket> m_socket;
+    const QString m_dsID;
+    const QString m_serverAddr;
+
+private:
+    void textMessageReceived(const QString &message);
+    bool sendTextMessage(const QLatin1String &dataType, const QJsonValue &data);
+
+signals:
+    void projectStarted();
+    void projectStarting();
+    void projectStopped();
+    void projectLogsReceived(const QString &logs);
+    void deviceInfoReady();
+    void projectSendingProgress(const int percentage);
+};

tests/scripts/run_test.sh

@@ -2,11 +2,11 @@
 # This script is used to run the test on the device and collect the logs and the test results.
 # Precondition: The device/emulator is connected/running and the test application is installed on it.
 
-adb shell "run-as io.qt.qtuiviewer.test rm -rf /data/data/io.qt.qtuiviewer.test/files/output.junitxml"
-adb shell am start -e applicationArguments "'-o output.junitxml,junitxml -v2'" -n io.qt.qtuiviewer.test/org.qtproject.qt.android.bindings.QtActivity
+adb shell "run-as io.qt.qtdesignviewer.test rm -rf /data/data/io.qt.qtdesignviewer.test/files/output.junitxml"
+adb shell am start -e applicationArguments "'-o output.junitxml,junitxml -v2'" -n io.qt.qtdesignviewer.test/org.qtproject.qt.android.bindings.QtActivity
 
 counter=0
-while [ -z "$(adb shell pidof -s io.qt.qtuiviewer.test)" ]; do
+while [ -z "$(adb shell pidof -s io.qt.qtdesignviewer.test)" ]; do
     echo "Waiting for test to start"
     sleep 0.1
     counter=$((counter + 1))
@@ -16,11 +16,11 @@ while [ -z "$(adb shell pidof -s io.qt.qtuiviewer.test)" ]; do
     fi
 done
 
-PID_OF_TEST=$(adb shell pidof -s io.qt.qtuiviewer.test)
+PID_OF_TEST=$(adb shell pidof -s io.qt.qtdesignviewer.test)
 echo "PID of test: ${PID_OF_TEST}"
 
 counter=0
-while [ -n "$(adb shell pidof -s io.qt.qtuiviewer.test)" ]; do
+while [ -n "$(adb shell pidof -s io.qt.qtdesignviewer.test)" ]; do
     echo "Waiting for test to finish. Elapsed time: $counter seconds"
     sleep 1
     counter=$((counter + 1))
@@ -32,4 +32,4 @@ done
 
 adb logcat -d --pid=${PID_OF_TEST}
 adb logcat -d --pid=${PID_OF_TEST} >logcat.txt
-adb shell "run-as io.qt.qtuiviewer.test cat /data/data/io.qt.qtuiviewer.test/files/output.junitxml" >output.junit.xml
+adb shell "run-as io.qt.qtdesignviewer.test cat /data/data/io.qt.qtdesignviewer.test/files/output.junitxml" >output.junit.xml

tests/tst_dsmanager.cpp

+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+#include "tst_dsmanager.h"
+
+#include <QTest>
+#include <QSignalSpy>
+
+#define DEVICE_ID "1234567890"
+#define DS_ID "0987654321"
+#define CONNECTION_TIMEOUT 1000
+
+TestObjects::TestObjects(const quint16 port, QObject *parent)
+    : QObject(parent)
+{
+    m_dsManager.reset(new DesignStudioManager(DEVICE_ID, port));
+    m_dsManager->init();
+
+    m_mockDS.reset(new MockDS(DS_ID, QString("ws://localhost:%1").arg(port), "DesignStudio"));
+
+    const bool rV = QTest::qWaitFor([&]() { return m_mockDS->isConnected(); }, CONNECTION_TIMEOUT);
+    QVERIFY(rV == true);
+
+    QSignalSpy spy(m_mockDS.data(), &MockDS::deviceInfoReady);
+    QVERIFY(m_mockDS->sendDesignStudioReady() == true);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+
+    m_mockDS2.reset(new MockDS(DS_ID "2", QString("ws://localhost:%1").arg(port), "DesignStudio"));
+    const bool rV2 = QTest::qWaitFor([&]() { return m_mockDS2->isConnected(); }, CONNECTION_TIMEOUT);
+    QVERIFY(rV2 == true);
+
+    QSignalSpy spy2(m_mockDS2.data(), &MockDS::deviceInfoReady);
+    QVERIFY(m_mockDS2->sendDesignStudioReady() == true);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+DesignStudioManager *TestObjects::designStudioManager()
+{
+    return m_dsManager.data();
+}
+
+MockDS *TestObjects::mockDS()
+{
+    return m_mockDS.data();
+}
+
+MockDS *TestObjects::mockDS2()
+{
+    return m_mockDS2.data();
+}
+
+void TestDesignStudioManager::initTestCase()
+{
+    QFile file(":/data/test_project/test_project_success.qmlrc");
+    qDebug() << "Reading file:" << file.fileName();
+    QVERIFY(file.open(QIODevice::ReadOnly));
+
+    m_projectData = file.readAll();
+    QVERIFY(m_projectData.size() > 0);
+
+    m_dsManager.reset(new DesignStudioManager(DEVICE_ID));
+    m_dsManager->init();
+
+    const QString serverName = m_dsManager->webSocketServerName();
+    const int serverPort = m_dsManager->webSocketServerPort();
+    // Important note:
+    // If the following 2 parameters change by a design decision,
+    // they have to be updated on Qt Design Studio side as well.
+    QVERIFY2(serverName == "DesignStudio",
+             "Default server name is not correct. Update the test and Design Studio side.");
+    QVERIFY2(serverPort == 40000,
+             "Default server port is not correct. Update the test and Design Studio side.");
+
+    const QString serverAddr = QString("ws://localhost:%1").arg(serverPort);
+
+    m_mockDS.reset(new MockDS(DS_ID, serverAddr, serverName));
+    const bool rV = QTest::qWaitFor([&]() { return m_mockDS->isConnected(); }, CONNECTION_TIMEOUT);
+    QVERIFY(rV == true);
+
+    QSignalSpy spy(m_mockDS.data(), &MockDS::deviceInfoReady);
+    QVERIFY(m_mockDS->sendDesignStudioReady() == true);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testSendProjectStarting()
+{
+    QSignalSpy spy(m_mockDS.data(), &MockDS::projectStarting);
+    m_dsManager->sendProjectStarting(DS_ID);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testSendProjectStarted()
+{
+    QSignalSpy spy(m_mockDS.data(), &MockDS::projectStarted);
+    m_dsManager->sendProjectStarted(DS_ID);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testSendProjectStopped()
+{
+    QSignalSpy spy(m_mockDS.data(), &MockDS::projectStopped);
+    m_dsManager->sendProjectStopped(DS_ID);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testSendProjectLogs()
+{
+    QSignalSpy spy(m_mockDS.data(), &MockDS::projectLogsReceived);
+    m_dsManager->sendProjectLogs(DS_ID, "Test logs");
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testProjectReceivingProgress()
+{
+    TestObjects testObjects(40001);
+    const QString qtVersion = "6.8.0";
+
+    QSignalSpy spy(testObjects.mockDS(), &MockDS::projectSendingProgress);
+    QVERIFY(testObjects.mockDS()->sendProjectData(m_projectData, qtVersion) == true);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testGetDesignStudioIp()
+{
+    TestObjects testObjects(40001);
+    const QString ipAddr = testObjects.designStudioManager()->getDesignStudioIp(DS_ID);
+    const QString failMessage = QString("Design Studio IP is not correct. Expected: %1, Got: %2")
+                                    .arg("::1 or ::ffff:127.0.0.1")
+                                    .arg(ipAddr);
+
+    if (ipAddr != "::1" && ipAddr != "::ffff:127.0.0.1")
+        QFAIL(qPrintable(failMessage));
+
+    QVERIFY(testObjects.designStudioManager()->getDesignStudioIp("non-existing-id").isEmpty());
+}
+
+void TestDesignStudioManager::testProjectVersionMismatch()
+{
+    TestObjects testObjects(40002);
+    const QString qtVersion = "5.0.0";
+
+    QSignalSpy spy(testObjects.designStudioManager(), &DesignStudioManager::projectVersionMismatch);
+    QVERIFY(testObjects.mockDS()->sendProjectData(m_projectData, qtVersion) == true);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testProjectIncoming()
+{
+    TestObjects testObjects(40003);
+    const QString qtVersion = "6.8.0";
+
+    QSignalSpy spy(testObjects.designStudioManager(), &DesignStudioManager::projectIncoming);
+    QVERIFY(testObjects.mockDS()->sendProjectData(m_projectData, qtVersion) == true);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testProjectIncomingProgress()
+{
+    TestObjects testObjects(40004);
+
+    const QString qtVersion = "6.8.0";
+    QByteArray bigProjectdata;
+    bigProjectdata.fill('a', 1024 * 1024 * 10);
+
+    QSignalSpy spy(testObjects.designStudioManager(), &DesignStudioManager::projectIncomingProgress);
+    QVERIFY(testObjects.mockDS()->sendProjectData(bigProjectdata, qtVersion) == true);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testProjectReceived()
+{
+    TestObjects testObjects(40005);
+    const QString qtVersion = "6.8.0";
+
+    QSignalSpy spy(testObjects.designStudioManager(), &DesignStudioManager::projectReceived);
+    QVERIFY(testObjects.mockDS()->sendProjectData(m_projectData, qtVersion) == true);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testDesignStudioConnected()
+{
+    TestObjects testObjects(40006);
+
+    QSignalSpy spy(testObjects.designStudioManager(), &DesignStudioManager::designStudioConnected);
+    testObjects.mockDS()->disconnect();
+    testObjects.mockDS()->connect();
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testDesignStudioDisconnected()
+{
+    TestObjects testObjects(40007);
+
+    QSignalSpy spy(testObjects.designStudioManager(),
+                   &DesignStudioManager::designStudioDisconnected);
+    testObjects.mockDS()->disconnect();
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}
+
+void TestDesignStudioManager::testAllDesignStudiosDisconnected()
+{
+    TestObjects testObjects(40008);
+
+    QSignalSpy spy(testObjects.designStudioManager(),
+                   &DesignStudioManager::designStudioDisconnected);
+    QSignalSpy spy2(testObjects.designStudioManager(),
+                    &DesignStudioManager::allDesignStudiosDisconnected);
+    testObjects.mockDS()->disconnect();
+    testObjects.mockDS2()->disconnect();
+    spy.wait(1000);
+    QCOMPARE(spy.count(), 2);
+    QCOMPARE(spy2.count(), 1);
+}
+
+void TestDesignStudioManager::testProjectStopRequested()
+{
+    TestObjects testObjects(40009);
+
+    QSignalSpy spy(testObjects.designStudioManager(), &DesignStudioManager::projectStopRequested);
+    testObjects.mockDS()->sendProjectStopped();
+    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 1000);
+}

tests/tst_dsmanager.h

+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#pragma once
+
+#include <QObject>
+
+#include "backend/dsconnector/dsmanager.h"
+#include "mock_ds.h"
+
+class TestObjects : public QObject
+{
+    Q_OBJECT
+public:
+    TestObjects(const quint16 port = 40000, QObject *parent = nullptr);
+    DesignStudioManager *designStudioManager();
+    MockDS *mockDS();
+    MockDS *mockDS2();
+
+private:
+    QScopedPointer<DesignStudioManager> m_dsManager;
+    QScopedPointer<MockDS> m_mockDS;
+    QScopedPointer<MockDS> m_mockDS2;
+};
+
+class TestDesignStudioManager : public QObject
+{
+    Q_OBJECT
+private slots:
+    void initTestCase();
+
+    // to DesignStudio
+    void testSendProjectStarted();
+    void testSendProjectStarting();
+    void testSendProjectStopped();
+    void testSendProjectLogs();
+    void testProjectReceivingProgress();
+    void testGetDesignStudioIp();
+
+    // to Android
+    void testProjectVersionMismatch();
+    void testProjectIncoming();
+    void testProjectIncomingProgress();
+    void testProjectReceived();
+    void testDesignStudioConnected();
+    void testDesignStudioDisconnected();
+    void testAllDesignStudiosDisconnected();
+    void testProjectStopRequested();
+
+private:
+    QScopedPointer<DesignStudioManager> m_dsManager;
+    QScopedPointer<MockDS> m_mockDS;
+    QByteArray m_projectData;
+};

tests/tst_projectmanager.cpp

+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "tst_projectmanager.h"
+
+#include <QQuickItem>
+#include <QSignalSpy>
+#include <QTest>
+
+void TestProjectManager::initTestCase()
+{
+    QFile file(":/data/test_project/test_project_success.qmlrc");
+    QVERIFY(file.open(QIODevice::ReadOnly));
+
+    m_projectThatCanRun = file.readAll();
+    QVERIFY(m_projectThatCanRun.size() > 0);
+
+    file.setFileName(":/data/test_project/test_project_fail.qmlrc");
+    QVERIFY(file.open(QIODevice::ReadOnly));
+
+    m_projectThatCannotRun = file.readAll();
+    QVERIFY(m_projectThatCannotRun.size() > 0);
+}
+
+void TestProjectManager::testRunProject()
+{
+    ProjectManager projectManager;
+    bool result = projectManager.runProject(m_projectThatCanRun, true, "sessionId");
+
+    QVERIFY(projectManager.sessionId() == "sessionId");
+    QVERIFY(result);
+
+    result = projectManager.runProject(m_projectThatCannotRun, true, "sessionId");
+    QVERIFY(!result);
+    QVERIFY(projectManager.sessionId().isEmpty());
+}
+
+void TestProjectManager::testStopProject()
+{
+    ProjectManager projectManager;
+    const bool result = projectManager.runProject(m_projectThatCanRun, true, "sessionId");
+    QVERIFY(result);
+
+    projectManager.stopProject();
+    QVERIFY(projectManager.sessionId().isEmpty());
+    QVERIFY(projectManager.m_quickWindow.isNull());
+    QVERIFY(projectManager.m_qmlEngine.isNull());
+    QVERIFY(projectManager.m_qmlComponent.isNull());
+}
+
+void TestProjectManager::testRegisterResource()
+{
+    ProjectManager projectManager;
+    const QString resourcePath = ":/data/test_project_register";
+    bool result = projectManager.registerResource(m_projectThatCanRun, resourcePath);
+    QVERIFY(result);
+
+    QFile file(resourcePath + "/test_project.qmlproject");
+    QVERIFY(file.open(QIODevice::ReadOnly));
+    QByteArray data = file.readAll();
+    QVERIFY(data.size() > 0);
+    QVERIFY(data.contains("import QmlProject"));
+    QVERIFY(data.contains("mainFile: \"test_projectContent/App.qml\""));
+
+    file.close();
+    file.setFileName(resourcePath + "/qtquickcontrols2.conf");
+    QVERIFY(file.open(QIODevice::ReadOnly));
+    data = file.readAll();
+    QVERIFY(data.size() > 0);
+    QVERIFY(data.contains("Style=Basic"));
+}
+
+void TestProjectManager::testUnregisterResource()
+{
+    ProjectManager projectManager;
+    const QString resourcePath = ":/data/test_project_unregister";
+    bool result = projectManager.registerResource(m_projectThatCanRun, resourcePath);
+    QVERIFY(result);
+
+    result = projectManager.unregisterResource(m_projectThatCanRun, resourcePath);
+    QVERIFY(result);
+
+    const QFile file(resourcePath + "/test_project.qmlproject");
+    QVERIFY(!file.exists());
+}
+
+void TestProjectManager::testCopyResourceToFs()
+{
+    ProjectManager projectManager;
+    const QString resourcePath = ":/data/test_project_copy";
+    bool result = projectManager.registerResource(m_projectThatCanRun, resourcePath);
+    QVERIFY(result);
+
+    const QString destinationPath = QDir::tempPath() + "/test_project_copy";
+    result = projectManager.copyResourceToFs(resourcePath, destinationPath);
+    QVERIFY(result);
+
+    const QStringList sourceFiles = QDir(resourcePath).entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
+    const QStringList destFiles = QDir(destinationPath).entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
+
+    QVERIFY(sourceFiles.size() == destFiles.size());
+    QCOMPARE(sourceFiles, destFiles);
+}
+
+void TestProjectManager::testUnpackProject()
+{
+    ProjectManager projectManager;
+    const QString projectPath = projectManager.unpackProject(m_projectThatCanRun);
+    QVERIFY(!projectPath.isEmpty());
+    QVERIFY(QFile::exists(projectPath + "/test_project.qmlproject"));
+    QVERIFY(QFile::exists(projectPath + "/qtquickcontrols2.conf"));
+}
+
+void TestProjectManager::testRunProjectInternal()
+{
+    ProjectManager projectManager;
+
+    const bool result = projectManager.runProjectInternal(m_projectThatCanRun);
+
+    QVERIFY(result);
+    QVERIFY(projectManager.m_qmlEngine);
+    QVERIFY(projectManager.m_qmlComponent);
+    QVERIFY(projectManager.m_quickWindow);
+    QVERIFY(projectManager.m_quickWindow->isVisible() == false);
+}
+
+void TestProjectManager::testFindFile()
+{
+    ProjectManager projectManager;
+    const QString projectPath = projectManager.unpackProject(m_projectThatCanRun);
+    QVERIFY(!projectPath.isEmpty());
+
+    const QString qmlProjectFile = projectManager.findFile(projectPath, "*.qmlproject", false);
+    QVERIFY(!qmlProjectFile.isEmpty());
+    QVERIFY(qmlProjectFile.contains("test_project.qmlproject"));
+}
+
+void TestProjectManager::testReadQmlProjectFile()
+{
+    ProjectManager projectManager;
+    const QString projectPath = projectManager.unpackProject(m_projectThatCanRun);
+    QVERIFY(!projectPath.isEmpty());
+
+    const QString qmlProjectFile = projectManager.findFile(projectPath, "*.qmlproject", false);
+    QVERIFY(!qmlProjectFile.isEmpty());
+
+    const QString qmlProjectFileContent = projectManager.readQmlProjectFile(qmlProjectFile);
+    QVERIFY(!qmlProjectFileContent.isEmpty());
+    QVERIFY(qmlProjectFileContent.contains("mainFile: \"test_projectContent/App.qml\""));
+}
+
+void TestProjectManager::testGetMainQmlFile()
+{
+    ProjectManager projectManager;
+    const QString projectPath = projectManager.unpackProject(m_projectThatCanRun);
+    QVERIFY(!projectPath.isEmpty());
+
+    const QString qmlProjectFile = projectManager.findFile(projectPath, "*.qmlproject", false);
+    QVERIFY(!qmlProjectFile.isEmpty());
+
+    const QString qmlProjectFileContent = projectManager.readQmlProjectFile(qmlProjectFile);
+    QVERIFY(!qmlProjectFileContent.isEmpty());
+
+    const QString mainQmlFile = projectManager.getMainQmlFile(projectPath, qmlProjectFileContent);
+    QVERIFY(!mainQmlFile.isEmpty());
+    QCOMPARE(mainQmlFile, projectPath + "/test_projectContent/App.qml");
+}
+
+void TestProjectManager::testGetImportPaths()
+{
+    ProjectManager projectManager;
+    const QString projectPath = projectManager.unpackProject(m_projectThatCanRun);
+    QVERIFY(!projectPath.isEmpty());
+
+    const QString qmlProjectFile = projectManager.findFile(projectPath, "*.qmlproject", false);
+    QVERIFY(!qmlProjectFile.isEmpty());
+
+    const QString qmlProjectFileContent = projectManager.readQmlProjectFile(qmlProjectFile);
+    QVERIFY(!qmlProjectFileContent.isEmpty());
+
+    const QStringList importPaths = projectManager.getImportPaths(projectPath, qmlProjectFileContent);
+    QVERIFY(importPaths.size() == 1);
+    QCOMPARE(importPaths.at(0), projectPath + "/.");
+}
+
+void TestProjectManager::testIsQt6Project()
+{
+    ProjectManager projectManager;
+    const QString projectPath = projectManager.unpackProject(m_projectThatCanRun);
+    QVERIFY(!projectPath.isEmpty());
+
+    const QString qmlProjectFile = projectManager.findFile(projectPath, "*.qmlproject", false);
+    QVERIFY(!qmlProjectFile.isEmpty());
+
+    const QString qmlProjectFileContent = projectManager.readQmlProjectFile(qmlProjectFile);
+    QVERIFY(!qmlProjectFileContent.isEmpty());
+
+    const bool result = projectManager.isQt6Project(qmlProjectFileContent);
+    QVERIFY(result);
+}
+
+void TestProjectManager::testShowAppWindow()
+{
+    ProjectManager projectManager;
+
+    projectManager.runProject(m_projectThatCanRun, true, "sessionId");
+    QVERIFY(projectManager.m_quickWindow->isVisible() == false);
+
+    projectManager.showAppWindow();
+    QVERIFY(projectManager.m_quickWindow->isVisible());
+}

tests/tst_projectmanager.h

+// Copyright (C) 2024 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#pragma once
+
+#include <QObject>
+
+#include "backend/projectmanager.h"
+
+class TestProjectManager : public QObject
+{
+    Q_OBJECT
+private slots:
+    void initTestCase();
+
+    // public methods
+    void testRunProject();
+    void testStopProject();
+
+    // protected methods - resource management
+    void testRegisterResource();
+    void testUnregisterResource();
+    void testCopyResourceToFs();
+    void testUnpackProject();
+
+    // protected methods - project management
+    void testRunProjectInternal();
+    void testFindFile();
+    void testReadQmlProjectFile();
+    void testGetMainQmlFile();
+    void testGetImportPaths();
+    void testIsQt6Project();
+
+    // protected methods - window management
+    void testShowAppWindow();
+
+private:
+    QByteArray m_projectThatCanRun;
+    QByteArray m_projectThatCannotRun;
+};

tests/tst_settings.cpp

@@ -5,22 +5,31 @@
 
 #include <QTest>
 
-#include "backend/settings.h"
+void TestSettings::initTestCase()
+{
+    QVERIFY(m_settings.clearSettings());
+}
 
 void TestSettings::testAutoScaleProject()
 {
-    Settings settings;
-    QVERIFY(settings.autoScaleProject());
+    QVERIFY(m_settings.autoScaleProject());
 
-    settings.setAutoScaleProject(false);
-    QVERIFY(!settings.autoScaleProject());
+    m_settings.setAutoScaleProject(false);
+    QVERIFY(!m_settings.autoScaleProject());
 }
 
 void TestSettings::testDeviceUuid()
 {
-    Settings settings;
-    QVERIFY(settings.deviceUuid().isEmpty());
+    QVERIFY(m_settings.deviceUuid().isEmpty());
+
+    m_settings.setDeviceUuid("1234567890");
+    QCOMPARE(m_settings.deviceUuid(), QString("1234567890"));
+}
+
+void TestSettings::testKeepScreenOn()
+{
+    QVERIFY(!m_settings.keepScreenOn());
 
-    settings.setDeviceUuid("1234567890");
-    QCOMPARE(settings.deviceUuid(), QString("1234567890"));
+    m_settings.setKeepScreenOn(true);
+    QVERIFY(m_settings.keepScreenOn());
 }

tests/tst_settings.h

@@ -5,11 +5,18 @@
 
 #include <QObject>
 
+#include "backend/settings.h"
+
 class TestSettings : public QObject
 {
     Q_OBJECT
 private slots:
+    void initTestCase();
 
     void testAutoScaleProject();
     void testDeviceUuid();
+    void testKeepScreenOn();
+
+private:
+    Settings m_settings;
 };