Merge branch 'develop' of https://github.com/PrismLauncher/PrismLauncher into export

Signed-off-by: Trial97 <alexandru.tripon97@gmail.com>

1 files changed, 67 insertions, 80 deletions

diff --git a/tests/Task_test.cpp b/tests/Task_test.cpp
index dabe5da2..c59d4bb7 100644
--- a/tests/Task_test.cpp
+++ b/tests/Task_test.cpp
@@ -1,6 +1,6 @@
 #include <QTest>
-#include <QTimer>
 #include <QThread>
+#include <QTimer>
 
 #include <tasks/ConcurrentTask.h>
 #include <tasks/MultipleOptionsTask.h>
@@ -19,10 +19,7 @@ class BasicTask : public Task {
     BasicTask(bool show_debug_log = true) : Task(nullptr, show_debug_log) {}
 
    private:
-    void executeTask() override
-    {
-        emitSucceeded();
-    };
+    void executeTask() override { emitSucceeded(); };
 };
 
 /* Does nothing. Only used for testing. */
@@ -34,7 +31,7 @@ class BasicTask_MultiStep : public Task {
    private:
     auto isMultiStep() const -> bool override { return true; }
 
-    void executeTask() override {};   
+    void executeTask() override{};
 };
 
 class BigConcurrentTask : public ConcurrentTask {
@@ -44,7 +41,7 @@ class BigConcurrentTask : public ConcurrentTask {
     {
         // This is here only to help fill the stack a bit more quickly (if there's an issue, of course :^))
         // Each tasks thus adds 1024 * 4 bytes to the stack, at the very least.
-        [[maybe_unused]] volatile std::array<uint32_t, 1024> some_data_on_the_stack {};
+        [[maybe_unused]] volatile std::array<uint32_t, 1024> some_data_on_the_stack{};
 
         ConcurrentTask::startNext();
     }
@@ -53,49 +50,42 @@ class BigConcurrentTask : public ConcurrentTask {
 class BigConcurrentTaskThread : public QThread {
     Q_OBJECT
 
-    BigConcurrentTask big_task;
-
+    QTimer m_deadline;
     void run() override
     {
-        QTimer deadline;
-        deadline.setInterval(10000);
-        connect(&deadline, &QTimer::timeout, this, [this]{ passed_the_deadline = true; });
-        deadline.start();
+        BigConcurrentTask big_task;
+        m_deadline.setInterval(10000);
 
         // NOTE: Arbitrary value that manages to trigger a problem when there is one.
         //       Considering each tasks, in a problematic state, adds 1024 * 4 bytes to the stack,
         //       this number is enough to fill up 16 MiB of stack, more than enough to cause a problem.
         static const unsigned s_num_tasks = 1 << 12;
-        auto sub_tasks = new BasicTask::Ptr[s_num_tasks];
-
         for (unsigned i = 0; i < s_num_tasks; i++) {
             auto sub_task = makeShared<BasicTask>(false);
-            sub_tasks[i] = sub_task;
             big_task.addTask(sub_task);
         }
 
-        big_task.run();
+        connect(&big_task, &Task::finished, this, &QThread::quit);
+        connect(&m_deadline, &QTimer::timeout, this, [&] { passed_the_deadline = true; quit(); });
 
-        while (!big_task.isFinished() && !passed_the_deadline)
-            QCoreApplication::processEvents();
+        m_deadline.start();
+        big_task.run();
 
-        emit finished();
+        exec();
     }
 
    public:
     bool passed_the_deadline = false;
-
-   signals:
-    void finished();
 };
 
 class TaskTest : public QObject {
     Q_OBJECT
 
    private slots:
-    void test_SetStatus_NoMultiStep(){
+    void test_SetStatus_NoMultiStep()
+    {
         BasicTask t;
-        QString status {"test status"};
+        QString status{ "test status" };
 
         t.setStatus(status);
 
@@ -103,9 +93,10 @@ class TaskTest : public QObject {
         QCOMPARE(t.getStepProgress().isEmpty(), TaskStepProgressList{}.isEmpty());
     }
 
-    void test_SetStatus_MultiStep(){
+    void test_SetStatus_MultiStep()
+    {
         BasicTask_MultiStep t;
-        QString status {"test status"};
+        QString status{ "test status" };
 
         t.setStatus(status);
 
@@ -115,7 +106,8 @@ class TaskTest : public QObject {
         QCOMPARE(t.getStepProgress().isEmpty(), TaskStepProgressList{}.isEmpty());
     }
 
-    void test_SetProgress(){
+    void test_SetProgress()
+    {
         BasicTask t;
         int current = 42;
         int total = 207;
@@ -126,17 +118,18 @@ class TaskTest : public QObject {
         QCOMPARE(t.getTotalProgress(), total);
     }
 
-    void test_basicRun(){
+    void test_basicRun()
+    {
         BasicTask t;
-        QObject::connect(&t, &Task::finished, [&]{ QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been."); });
+        QObject::connect(&t, &Task::finished,
+                         [&] { QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been."); });
         t.start();
 
-        QVERIFY2(QTest::qWaitFor([&]() {
-            return t.isFinished();
-        }, 1000), "Task didn't finish as it should.");
+        QVERIFY2(QTest::qWaitFor([&]() { return t.isFinished(); }, 1000), "Task didn't finish as it should.");
     }
 
-    void test_basicConcurrentRun(){
+    void test_basicConcurrentRun()
+    {
         auto t1 = makeShared<BasicTask>();
         auto t2 = makeShared<BasicTask>();
         auto t3 = makeShared<BasicTask>();
@@ -147,21 +140,20 @@ class TaskTest : public QObject {
         t.addTask(t2);
         t.addTask(t3);
 
-        QObject::connect(&t, &Task::finished, [&]{
-                QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
-                QVERIFY(t1->wasSuccessful());
-                QVERIFY(t2->wasSuccessful());
-                QVERIFY(t3->wasSuccessful());
+        QObject::connect(&t, &Task::finished, [&t, &t1, &t2, &t3] {
+            QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
+            QVERIFY(t1->wasSuccessful());
+            QVERIFY(t2->wasSuccessful());
+            QVERIFY(t3->wasSuccessful());
         });
 
         t.start();
-        QVERIFY2(QTest::qWaitFor([&]() {
-            return t.isFinished();
-        }, 1000), "Task didn't finish as it should.");
+        QVERIFY2(QTest::qWaitFor([&]() { return t.isFinished(); }, 1000), "Task didn't finish as it should.");
     }
 
     // Tests if starting new tasks after the 6 initial ones is working
-    void test_moreConcurrentRun(){
+    void test_moreConcurrentRun()
+    {
         auto t1 = makeShared<BasicTask>();
         auto t2 = makeShared<BasicTask>();
         auto t3 = makeShared<BasicTask>();
@@ -184,26 +176,25 @@ class TaskTest : public QObject {
         t.addTask(t8);
         t.addTask(t9);
 
-        QObject::connect(&t, &Task::finished, [&]{
-                QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
-                QVERIFY(t1->wasSuccessful());
-                QVERIFY(t2->wasSuccessful());
-                QVERIFY(t3->wasSuccessful());
-                QVERIFY(t4->wasSuccessful());
-                QVERIFY(t5->wasSuccessful());
-                QVERIFY(t6->wasSuccessful());
-                QVERIFY(t7->wasSuccessful());
-                QVERIFY(t8->wasSuccessful());
-                QVERIFY(t9->wasSuccessful());
+        QObject::connect(&t, &Task::finished, [&t, &t1, &t2, &t3, &t4, &t5, &t6, &t7, &t8, &t9] {
+            QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
+            QVERIFY(t1->wasSuccessful());
+            QVERIFY(t2->wasSuccessful());
+            QVERIFY(t3->wasSuccessful());
+            QVERIFY(t4->wasSuccessful());
+            QVERIFY(t5->wasSuccessful());
+            QVERIFY(t6->wasSuccessful());
+            QVERIFY(t7->wasSuccessful());
+            QVERIFY(t8->wasSuccessful());
+            QVERIFY(t9->wasSuccessful());
         });
 
         t.start();
-        QVERIFY2(QTest::qWaitFor([&]() {
-            return t.isFinished();
-        }, 1000), "Task didn't finish as it should.");
+        QVERIFY2(QTest::qWaitFor([&]() { return t.isFinished(); }, 1000), "Task didn't finish as it should.");
     }
 
-    void test_basicSequentialRun(){
+    void test_basicSequentialRun()
+    {
         auto t1 = makeShared<BasicTask>();
         auto t2 = makeShared<BasicTask>();
         auto t3 = makeShared<BasicTask>();
@@ -214,20 +205,19 @@ class TaskTest : public QObject {
         t.addTask(t2);
         t.addTask(t3);
 
-        QObject::connect(&t, &Task::finished, [&]{
-                QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
-                QVERIFY(t1->wasSuccessful());
-                QVERIFY(t2->wasSuccessful());
-                QVERIFY(t3->wasSuccessful());
+        QObject::connect(&t, &Task::finished, [&t, &t1, &t2, &t3] {
+            QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
+            QVERIFY(t1->wasSuccessful());
+            QVERIFY(t2->wasSuccessful());
+            QVERIFY(t3->wasSuccessful());
         });
 
         t.start();
-        QVERIFY2(QTest::qWaitFor([&]() {
-            return t.isFinished();
-        }, 1000), "Task didn't finish as it should.");
+        QVERIFY2(QTest::qWaitFor([&]() { return t.isFinished(); }, 1000), "Task didn't finish as it should.");
     }
 
-    void test_basicMultipleOptionsRun(){
+    void test_basicMultipleOptionsRun()
+    {
         auto t1 = makeShared<BasicTask>();
         auto t2 = makeShared<BasicTask>();
         auto t3 = makeShared<BasicTask>();
@@ -238,33 +228,30 @@ class TaskTest : public QObject {
         t.addTask(t2);
         t.addTask(t3);
 
-        QObject::connect(&t, &Task::finished, [&]{
-                QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
-                QVERIFY(t1->wasSuccessful());
-                QVERIFY(!t2->wasSuccessful());
-                QVERIFY(!t3->wasSuccessful());
+        QObject::connect(&t, &Task::finished, [&t, &t1, &t2, &t3] {
+            QVERIFY2(t.wasSuccessful(), "Task finished but was not successful when it should have been.");
+            QVERIFY(t1->wasSuccessful());
+            QVERIFY(!t2->wasSuccessful());
+            QVERIFY(!t3->wasSuccessful());
         });
 
         t.start();
-        QVERIFY2(QTest::qWaitFor([&]() {
-            return t.isFinished();
-        }, 1000), "Task didn't finish as it should.");
+        QVERIFY2(QTest::qWaitFor([&]() { return t.isFinished(); }, 1000), "Task didn't finish as it should.");
     }
 
     void test_stackOverflowInConcurrentTask()
     {
         QEventLoop loop;
 
-        auto thread = new BigConcurrentTaskThread;
+        BigConcurrentTaskThread thread;
 
-        connect(thread, &BigConcurrentTaskThread::finished, &loop, &QEventLoop::quit);
+        connect(&thread, &BigConcurrentTaskThread::finished, &loop, &QEventLoop::quit);
 
-        thread->start();
+        thread.start();
 
         loop.exec();
 
-        QVERIFY(!thread->passed_the_deadline);
-        thread->deleteLater();
+        QVERIFY(!thread.passed_the_deadline);
     }
 };