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

28 files changed, 1292 insertions, 94 deletions

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 630f1200..36a3b0f8 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -24,9 +24,21 @@ ecm_add_test(ResourceFolderModel_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_V
 ecm_add_test(ResourcePackParse_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_VERSION_MAJOR}::Test
     TEST_NAME ResourcePackParse)
 
+ecm_add_test(ResourceModel_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_VERSION_MAJOR}::Test
+    TEST_NAME ResourceModel)
+
 ecm_add_test(TexturePackParse_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_VERSION_MAJOR}::Test
     TEST_NAME TexturePackParse)
 
+ecm_add_test(DataPackParse_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_VERSION_MAJOR}::Test
+    TEST_NAME DataPackParse)
+
+ecm_add_test(ShaderPackParse_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_VERSION_MAJOR}::Test
+    TEST_NAME ShaderPackParse)
+
+ecm_add_test(WorldSaveParse_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_VERSION_MAJOR}::Test
+    TEST_NAME WorldSaveParse)
+
 ecm_add_test(ParseUtils_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_VERSION_MAJOR}::Test
     TEST_NAME ParseUtils)
 
@@ -44,3 +56,6 @@ ecm_add_test(Packwiz_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_VERSION_MAJOR
 
 ecm_add_test(Index_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_VERSION_MAJOR}::Test
     TEST_NAME Index)
+
+ecm_add_test(Version_test.cpp LINK_LIBRARIES Launcher_logic Qt${QT_VERSION_MAJOR}::Test
+    TEST_NAME Version)
diff --git a/tests/DataPackParse_test.cpp b/tests/DataPackParse_test.cpp
new file mode 100644
index 00000000..61ce1e2b
--- /dev/null
+++ b/tests/DataPackParse_test.cpp
@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: 2022 Rachel Powers <508861+Ryex@users.noreply.github.com>
+//
+// SPDX-License-Identifier: GPL-3.0-only
+
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2022 Rachel Powers <508861+Ryex@users.noreply.github.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QTest>
+#include <QTimer>
+
+#include <FileSystem.h>
+
+#include <minecraft/mod/DataPack.h>
+#include <minecraft/mod/tasks/LocalDataPackParseTask.h>
+
+class DataPackParseTest : public QObject {
+    Q_OBJECT
+
+    private slots:
+    void test_parseZIP()
+    {
+        QString source = QFINDTESTDATA("testdata/DataPackParse");
+
+        QString zip_dp = FS::PathCombine(source, "test_data_pack_boogaloo.zip");
+        DataPack pack { QFileInfo(zip_dp) };
+
+        bool valid = DataPackUtils::processZIP(pack);
+
+        QVERIFY(pack.packFormat() == 4);
+        QVERIFY(pack.description() == "Some data pack 2 boobgaloo");
+        QVERIFY(valid == true);
+    }
+
+    void test_parseFolder()
+    {
+        QString source = QFINDTESTDATA("testdata/DataPackParse");
+
+        QString folder_dp = FS::PathCombine(source, "test_folder");
+        DataPack pack { QFileInfo(folder_dp) };
+
+        bool valid = DataPackUtils::processFolder(pack);
+
+        QVERIFY(pack.packFormat() == 10);
+        QVERIFY(pack.description() == "Some data pack, maybe");
+        QVERIFY(valid == true);
+    }
+
+    void test_parseFolder2()
+    {
+        QString source = QFINDTESTDATA("testdata/DataPackParse");
+
+        QString folder_dp = FS::PathCombine(source, "another_test_folder");
+        DataPack pack { QFileInfo(folder_dp) };
+
+        bool valid = DataPackUtils::process(pack);
+
+        QVERIFY(pack.packFormat() == 6);
+        QVERIFY(pack.description() == "Some data pack three, leaves on the tree");
+        QVERIFY(valid == true);
+    }
+};
+
+QTEST_GUILESS_MAIN(DataPackParseTest)
+
+#include "DataPackParse_test.moc"
diff --git a/tests/DummyResourceAPI.h b/tests/DummyResourceAPI.h
new file mode 100644
index 00000000..0cc90958
--- /dev/null
+++ b/tests/DummyResourceAPI.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <QJsonDocument>
+
+#include <modplatform/ResourceAPI.h>
+
+class SearchTask : public Task {
+    Q_OBJECT
+
+   public:
+    void executeTask() override { emitSucceeded(); }
+};
+
+class DummyResourceAPI : public ResourceAPI {
+   public:
+    static auto searchRequestResult()
+    {
+        static QByteArray json_response =
+            "{\"hits\":["
+            "{"
+            "\"author\":\"flowln\","
+            "\"description\":\"the bestest mod\","
+            "\"project_id\":\"something\","
+            "\"project_type\":\"mod\","
+            "\"slug\":\"bip_bop\","
+            "\"title\":\"AAAAAAAA\","
+            "\"versions\":[\"2.71\"]"
+            "}"
+            "]}";
+
+        return QJsonDocument::fromJson(json_response);
+    }
+
+    DummyResourceAPI() : ResourceAPI() {}
+    [[nodiscard]] auto getSortingMethods() const -> QList<SortingMethod> override { return {}; };
+
+    [[nodiscard]] Task::Ptr searchProjects(SearchArgs&&, SearchCallbacks&& callbacks) const override
+    {
+        auto task = makeShared<SearchTask>();
+        QObject::connect(task.get(), &Task::succeeded, [=] {
+            auto json = searchRequestResult();
+            callbacks.on_succeed(json);
+        });
+        return task;
+    }
+};
diff --git a/tests/FileSystem_test.cpp b/tests/FileSystem_test.cpp
index 3a5c38d0..ec1f0bcf 100644
--- a/tests/FileSystem_test.cpp
+++ b/tests/FileSystem_test.cpp
@@ -1,11 +1,104 @@
 #include <QTest>
+#include <QDir>
 #include <QTemporaryDir>
 #include <QStandardPaths>
 
+#include <tasks/Task.h>
+
 #include <FileSystem.h>
+#include <StringUtils.h>
+
+// Snippet from https://github.com/gulrak/filesystem#using-it-as-single-file-header
+
+#ifdef __APPLE__
+#include <Availability.h> // for deployment target to support pre-catalina targets without std::fs
+#endif // __APPLE__
+
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+#if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
+#define GHC_USE_STD_FS
+#include <filesystem>
+namespace fs = std::filesystem;
+#endif // MacOS min version check
+#endif // Other OSes version check
+
+#ifndef GHC_USE_STD_FS
+#include <ghc/filesystem.hpp>
+namespace fs = ghc::filesystem;
+#endif
 
 #include <pathmatcher/RegexpMatcher.h>
 
+
+
+class LinkTask : public Task {
+    Q_OBJECT
+
+    friend class FileSystemTest;
+
+    LinkTask(QString src, QString dst)
+    {
+        m_lnk = new FS::create_link(src, dst, this);
+        m_lnk->debug(true);
+    }
+
+    void matcher(const IPathMatcher *filter)
+    {
+        m_lnk->matcher(filter);
+    }
+
+    void linkRecursively(bool recursive) 
+    {
+        m_lnk->linkRecursively(recursive);
+        m_linkRecursive = recursive;
+    }
+
+    void whitelist(bool b)
+    {
+        m_lnk->whitelist(b);
+    }
+
+    void setMaxDepth(int depth)
+    {
+        m_lnk->setMaxDepth(depth);
+    }
+
+   private:
+    void executeTask() override
+    {
+        if(!(*m_lnk)()){
+#if defined Q_OS_WIN32
+            if (!m_useHard) {
+                qDebug() << "EXPECTED: Link failure, Windows requires permissions for symlinks";
+
+                qDebug() << "atempting to run with privelage";
+                connect(m_lnk, &FS::create_link::finishedPrivileged, this, [&](bool gotResults){
+                    if (gotResults) {
+                        emitSucceeded();
+                    } else {
+                        qDebug() << "Privileged run exited without results!";
+                        emitFailed();
+                    }
+                });
+                m_lnk->runPrivileged();
+            } else {
+                qDebug() << "Link Failed!" << m_lnk->getOSError().value() << m_lnk->getOSError().message().c_str();
+            }      
+#else
+            qDebug() << "Link Failed!" << m_lnk->getOSError().value() << m_lnk->getOSError().message().c_str();
+#endif
+        } else {
+            emitSucceeded();
+        }
+        
+    };
+
+    FS::create_link *m_lnk;
+    bool m_useHard = false;
+    bool m_linkRecursive = true;
+};
+
+
 class FileSystemTest : public QObject
 {
     Q_OBJECT
@@ -248,6 +341,447 @@ slots:
     {
         QCOMPARE(FS::getDesktopDir(), QStandardPaths::writableLocation(QStandardPaths::DesktopLocation));
     }
+
+
+    void test_link()
+    {
+        QString folder = QFINDTESTDATA("testdata/FileSystem/test_folder");
+        auto f = [&folder, this]()
+        {
+            QTemporaryDir tempDir;
+            tempDir.setAutoRemove(true);
+            qDebug() << "From:" << folder << "To:" << tempDir.path();
+
+            QDir target_dir(FS::PathCombine(tempDir.path(), "test_folder"));
+            qDebug() << tempDir.path();
+            qDebug() << target_dir.path();
+
+            LinkTask lnk_tsk(folder, target_dir.path());
+            lnk_tsk.linkRecursively(false);
+            QObject::connect(&lnk_tsk, &Task::finished, [&]{ 
+                QVERIFY2(lnk_tsk.wasSuccessful(), "Task finished but was not successful when it should have been."); 
+            });
+            lnk_tsk.start();
+
+            QVERIFY2(QTest::qWaitFor([&]() {
+                return lnk_tsk.isFinished();
+            }, 100000), "Task didn't finish as it should.");
+
+            for(auto entry: target_dir.entryList())
+            {
+                qDebug() << entry;
+                QFileInfo entry_lnk_info(target_dir.filePath(entry));
+                if (!entry_lnk_info.isDir())
+                    QVERIFY(!entry_lnk_info.isSymLink());
+            }
+
+            QFileInfo lnk_info(target_dir.path());
+            QVERIFY(lnk_info.exists());
+            QVERIFY(lnk_info.isSymLink());
+
+            QVERIFY(target_dir.entryList().contains("pack.mcmeta"));
+            QVERIFY(target_dir.entryList().contains("assets"));
+        };
+
+        // first try variant without trailing /
+        QVERIFY(!folder.endsWith('/'));
+        f();
+
+        // then variant with trailing /
+        folder.append('/');
+        QVERIFY(folder.endsWith('/'));
+        f();
+    }
+
+    void test_hard_link()
+    {
+        QString folder = QFINDTESTDATA("testdata/FileSystem/test_folder");
+        auto f = [&folder]()
+        {   
+            // use working dir to prevent makeing a hard link to a tmpfs or across devices
+            QTemporaryDir tempDir("./tmp"); 
+            tempDir.setAutoRemove(true);
+            qDebug() << "From:" << folder << "To:" << tempDir.path();
+
+            QDir target_dir(FS::PathCombine(tempDir.path(), "test_folder"));
+            qDebug() << tempDir.path();
+            qDebug() << target_dir.path();
+            FS::create_link lnk(folder, target_dir.path());
+            lnk.useHardLinks(true);
+            lnk.debug(true);
+            if(!lnk()){
+                qDebug() << "Link Failed!" << lnk.getOSError().value() << lnk.getOSError().message().c_str();
+            }
+
+            for(auto entry: target_dir.entryList())
+            {
+                qDebug() << entry;
+                QFileInfo entry_lnk_info(target_dir.filePath(entry));
+                QVERIFY(!entry_lnk_info.isSymLink());
+                QFileInfo entry_orig_info(QDir(folder).filePath(entry));
+                if (!entry_lnk_info.isDir()) {
+                    qDebug() << "hard link equivalency?" << entry_lnk_info.absoluteFilePath() << "vs" << entry_orig_info.absoluteFilePath();
+                    QVERIFY(fs::equivalent(
+                        fs::path(StringUtils::toStdString(entry_lnk_info.absoluteFilePath())),
+                        fs::path(StringUtils::toStdString(entry_orig_info.absoluteFilePath()))
+                    ));
+                } 
+            }
+
+            QFileInfo lnk_info(target_dir.path());
+            QVERIFY(lnk_info.exists());
+            QVERIFY(!lnk_info.isSymLink());
+
+            QVERIFY(target_dir.entryList().contains("pack.mcmeta"));
+            QVERIFY(target_dir.entryList().contains("assets"));
+        };
+
+        // first try variant without trailing /
+        QVERIFY(!folder.endsWith('/'));
+        f();
+
+        // then variant with trailing /
+        folder.append('/');
+        QVERIFY(folder.endsWith('/'));
+        f();
+    }
+
+    void test_link_with_blacklist()
+    {
+        QString folder = QFINDTESTDATA("testdata/FileSystem/test_folder");
+        auto f = [&folder]()
+        {
+            QTemporaryDir tempDir;
+            tempDir.setAutoRemove(true);
+            qDebug() << "From:" << folder << "To:" << tempDir.path();
+
+            QDir target_dir(FS::PathCombine(tempDir.path(), "test_folder"));
+            qDebug() << tempDir.path();
+            qDebug() << target_dir.path();
+
+            LinkTask lnk_tsk(folder, target_dir.path());
+            lnk_tsk.matcher(new RegexpMatcher("[.]?mcmeta"));
+            lnk_tsk.linkRecursively(true);
+            QObject::connect(&lnk_tsk, &Task::finished, [&]{ 
+                QVERIFY2(lnk_tsk.wasSuccessful(), "Task finished but was not successful when it should have been."); 
+            });
+            lnk_tsk.start();
+
+            QVERIFY2(QTest::qWaitFor([&]() {
+                return lnk_tsk.isFinished();
+            }, 100000), "Task didn't finish as it should.");
+
+
+            for(auto entry: target_dir.entryList())
+            {
+                qDebug() << entry;
+                QFileInfo entry_lnk_info(target_dir.filePath(entry));
+                if (!entry_lnk_info.isDir())
+                    QVERIFY(entry_lnk_info.isSymLink());
+            }
+
+            QFileInfo lnk_info(target_dir.path());
+            QVERIFY(lnk_info.exists());
+
+            QVERIFY(!target_dir.entryList().contains("pack.mcmeta"));
+            QVERIFY(target_dir.entryList().contains("assets"));
+        };
+
+        // first try variant without trailing /
+        QVERIFY(!folder.endsWith('/'));
+        f();
+
+        // then variant with trailing /
+        folder.append('/');
+        QVERIFY(folder.endsWith('/'));
+        f();
+    }
+
+    void test_link_with_whitelist()
+    {
+        QString folder = QFINDTESTDATA("testdata/FileSystem/test_folder");
+        auto f = [&folder]()
+        {
+            QTemporaryDir tempDir;
+            tempDir.setAutoRemove(true);
+            qDebug() << "From:" << folder << "To:" << tempDir.path();
+
+            QDir target_dir(FS::PathCombine(tempDir.path(), "test_folder"));
+            qDebug() << tempDir.path();
+            qDebug() << target_dir.path();
+
+            LinkTask lnk_tsk(folder, target_dir.path());
+            lnk_tsk.matcher(new RegexpMatcher("[.]?mcmeta"));
+            lnk_tsk.linkRecursively(true);
+            lnk_tsk.whitelist(true);
+            QObject::connect(&lnk_tsk, &Task::finished, [&]{ 
+                QVERIFY2(lnk_tsk.wasSuccessful(), "Task finished but was not successful when it should have been."); 
+            });
+            lnk_tsk.start();
+
+            QVERIFY2(QTest::qWaitFor([&]() {
+                return lnk_tsk.isFinished();
+            }, 100000), "Task didn't finish as it should.");
+
+            for(auto entry: target_dir.entryList())
+            {
+                qDebug() << entry;
+                QFileInfo entry_lnk_info(target_dir.filePath(entry));
+                if (!entry_lnk_info.isDir())
+                    QVERIFY(entry_lnk_info.isSymLink());
+            }
+
+            QFileInfo lnk_info(target_dir.path());
+            QVERIFY(lnk_info.exists());
+
+            QVERIFY(target_dir.entryList().contains("pack.mcmeta"));
+            QVERIFY(!target_dir.entryList().contains("assets"));
+        };
+
+        // first try variant without trailing /
+        QVERIFY(!folder.endsWith('/'));
+        f();
+
+        // then variant with trailing /
+        folder.append('/');
+        QVERIFY(folder.endsWith('/'));
+        f();
+    }
+
+    void test_link_with_dot_hidden()
+    {
+        QString folder = QFINDTESTDATA("testdata/FileSystem/test_folder");
+        auto f = [&folder]()
+        {
+            QTemporaryDir tempDir;
+            tempDir.setAutoRemove(true);
+            qDebug() << "From:" << folder << "To:" << tempDir.path();
+
+            QDir target_dir(FS::PathCombine(tempDir.path(), "test_folder"));
+            qDebug() << tempDir.path();
+            qDebug() << target_dir.path();
+
+            LinkTask lnk_tsk(folder, target_dir.path());
+            lnk_tsk.linkRecursively(true);
+            QObject::connect(&lnk_tsk, &Task::finished, [&]{ 
+                QVERIFY2(lnk_tsk.wasSuccessful(), "Task finished but was not successful when it should have been."); 
+            });
+            lnk_tsk.start();
+
+            QVERIFY2(QTest::qWaitFor([&]() {
+                return lnk_tsk.isFinished();
+            }, 100000), "Task didn't finish as it should.");
+
+            auto filter = QDir::Filter::Files | QDir::Filter::Dirs | QDir::Filter::Hidden;
+
+            for (auto entry: target_dir.entryList(filter)) {
+                qDebug() << entry;
+                QFileInfo entry_lnk_info(target_dir.filePath(entry));
+                if (!entry_lnk_info.isDir())
+                    QVERIFY(entry_lnk_info.isSymLink());
+            }
+
+            QFileInfo lnk_info(target_dir.path());
+            QVERIFY(lnk_info.exists());
+
+            QVERIFY(target_dir.entryList(filter).contains(".secret_folder"));
+            target_dir.cd(".secret_folder");
+            QVERIFY(target_dir.entryList(filter).contains(".secret_file.txt"));
+        };
+
+        // first try variant without trailing /
+        QVERIFY(!folder.endsWith('/'));
+        f();
+
+        // then variant with trailing /
+        folder.append('/');
+        QVERIFY(folder.endsWith('/'));
+        f();
+    }
+
+    void test_link_single_file()
+    {
+        QTemporaryDir tempDir;
+        tempDir.setAutoRemove(true);
+
+        {
+            QString file = QFINDTESTDATA("testdata/FileSystem/test_folder/pack.mcmeta");
+
+            qDebug() << "From:" << file << "To:" << tempDir.path();
+
+            QDir target_dir(FS::PathCombine(tempDir.path(), "pack.mcmeta"));
+            qDebug() << tempDir.path();
+            qDebug() << target_dir.path();
+
+            LinkTask lnk_tsk(file,  target_dir.filePath("pack.mcmeta"));
+            QObject::connect(&lnk_tsk, &Task::finished, [&]{ 
+                QVERIFY2(lnk_tsk.wasSuccessful(), "Task finished but was not successful when it should have been."); 
+            });
+            lnk_tsk.start();
+
+            QVERIFY2(QTest::qWaitFor([&]() {
+                return lnk_tsk.isFinished();
+            }, 100000), "Task didn't finish as it should.");
+
+            auto filter = QDir::Filter::Files;
+
+            for (auto entry: target_dir.entryList(filter)) {
+                qDebug() << entry;
+            }
+
+            QFileInfo lnk_info(target_dir.filePath("pack.mcmeta"));
+            QVERIFY(lnk_info.exists());
+            QVERIFY(lnk_info.isSymLink());
+
+            QVERIFY(target_dir.entryList(filter).contains("pack.mcmeta"));
+        }
+    }
+
+    void test_link_with_max_depth()
+    {
+        QString folder = QFINDTESTDATA("testdata/FileSystem/test_folder");
+        auto f = [&folder, this]()
+        {
+            QTemporaryDir tempDir;
+            tempDir.setAutoRemove(true);
+            qDebug() << "From:" << folder << "To:" << tempDir.path();
+
+            QDir target_dir(FS::PathCombine(tempDir.path(), "test_folder"));
+            qDebug() << tempDir.path();
+            qDebug() << target_dir.path();
+
+            LinkTask lnk_tsk(folder, target_dir.path());
+            lnk_tsk.linkRecursively(true);
+            lnk_tsk.setMaxDepth(0);
+            QObject::connect(&lnk_tsk, &Task::finished, [&]{ 
+                QVERIFY2(lnk_tsk.wasSuccessful(), "Task finished but was not successful when it should have been."); 
+            });
+            lnk_tsk.start();
+
+            QVERIFY2(QTest::qWaitFor([&]() {
+                return lnk_tsk.isFinished();
+            }, 100000), "Task didn't finish as it should.");
+
+            QVERIFY(!QFileInfo(target_dir.path()).isSymLink());
+
+            auto filter = QDir::Filter::Files | QDir::Filter::Dirs | QDir::Filter::Hidden;
+            for(auto entry: target_dir.entryList(filter))
+            {
+                qDebug() << entry;
+                if (entry == "." || entry == "..") continue;
+                QFileInfo entry_lnk_info(target_dir.filePath(entry));
+                QVERIFY(entry_lnk_info.isSymLink());
+            }
+
+            QFileInfo lnk_info(target_dir.path());
+            QVERIFY(lnk_info.exists());
+            QVERIFY(!lnk_info.isSymLink());
+
+            QVERIFY(target_dir.entryList().contains("pack.mcmeta"));
+            QVERIFY(target_dir.entryList().contains("assets"));
+
+
+        };
+
+        // first try variant without trailing /
+        QVERIFY(!folder.endsWith('/'));
+        f();
+
+        // then variant with trailing /
+        folder.append('/');
+        QVERIFY(folder.endsWith('/'));
+        f();
+    }
+
+    void test_link_with_no_max_depth()
+    {
+        QString folder = QFINDTESTDATA("testdata/FileSystem/test_folder");
+        auto f = [&folder]()
+        {
+            QTemporaryDir tempDir;
+            tempDir.setAutoRemove(true);
+            qDebug() << "From:" << folder << "To:" << tempDir.path();
+
+            QDir target_dir(FS::PathCombine(tempDir.path(), "test_folder"));
+            qDebug() << tempDir.path();
+            qDebug() << target_dir.path();
+
+            LinkTask lnk_tsk(folder, target_dir.path());
+            lnk_tsk.linkRecursively(true);
+            lnk_tsk.setMaxDepth(-1);
+            QObject::connect(&lnk_tsk, &Task::finished, [&]{ 
+                QVERIFY2(lnk_tsk.wasSuccessful(), "Task finished but was not successful when it should have been."); 
+            });
+            lnk_tsk.start();
+
+            QVERIFY2(QTest::qWaitFor([&]() {
+                return lnk_tsk.isFinished();
+            }, 100000), "Task didn't finish as it should.");
+
+
+            std::function<void(QString)> verify_check = [&](QString check_path) {
+                QDir check_dir(check_path);
+                auto filter = QDir::Filter::Files | QDir::Filter::Dirs | QDir::Filter::Hidden;
+                for(auto entry: check_dir.entryList(filter))
+                {
+                    QFileInfo entry_lnk_info(check_dir.filePath(entry));
+                    qDebug() << entry << check_dir.filePath(entry);
+                    if (!entry_lnk_info.isDir()){
+                        QVERIFY(entry_lnk_info.isSymLink());
+                    } else if (entry != "." && entry != "..") {
+                        qDebug() << "Decending tree to verify symlinks:" << check_dir.filePath(entry);
+                        verify_check(entry_lnk_info.filePath());
+                    }
+                }
+            };
+            
+            verify_check(target_dir.path());
+            
+
+            QFileInfo lnk_info(target_dir.path());
+            QVERIFY(lnk_info.exists());
+
+            QVERIFY(target_dir.entryList().contains("pack.mcmeta"));
+            QVERIFY(target_dir.entryList().contains("assets"));
+        };
+
+        // first try variant without trailing /
+        QVERIFY(!folder.endsWith('/'));
+        f();
+
+        // then variant with trailing /
+        folder.append('/');
+        QVERIFY(folder.endsWith('/'));
+        f();
+    }
+
+    void test_path_depth() {
+        QCOMPARE(FS::pathDepth(""), 0);
+        QCOMPARE(FS::pathDepth("."), 0);
+        QCOMPARE(FS::pathDepth("foo.txt"), 0);
+        QCOMPARE(FS::pathDepth("./foo.txt"), 0);
+        QCOMPARE(FS::pathDepth("./bar/foo.txt"), 1);
+        QCOMPARE(FS::pathDepth("../bar/foo.txt"), 0);
+        QCOMPARE(FS::pathDepth("/bar/foo.txt"), 1);
+        QCOMPARE(FS::pathDepth("baz/bar/foo.txt"), 2);
+        QCOMPARE(FS::pathDepth("/baz/bar/foo.txt"), 2);
+        QCOMPARE(FS::pathDepth("./baz/bar/foo.txt"), 2);
+        QCOMPARE(FS::pathDepth("/baz/../bar/foo.txt"), 1);
+    }
+
+    void test_path_trunc() {
+        QCOMPARE(FS::pathTruncate("", 0), QDir::toNativeSeparators(""));
+        QCOMPARE(FS::pathTruncate("foo.txt", 0), QDir::toNativeSeparators(""));
+        QCOMPARE(FS::pathTruncate("foo.txt", 1), QDir::toNativeSeparators(""));
+        QCOMPARE(FS::pathTruncate("./bar/foo.txt", 0), QDir::toNativeSeparators("./bar"));
+        QCOMPARE(FS::pathTruncate("./bar/foo.txt", 1), QDir::toNativeSeparators("./bar"));
+        QCOMPARE(FS::pathTruncate("/bar/foo.txt", 1), QDir::toNativeSeparators("/bar"));
+        QCOMPARE(FS::pathTruncate("bar/foo.txt", 1), QDir::toNativeSeparators("bar"));
+        QCOMPARE(FS::pathTruncate("baz/bar/foo.txt", 2), QDir::toNativeSeparators("baz/bar"));
+#if defined(Q_OS_WIN)
+        QCOMPARE(FS::pathTruncate("C:\\bar\\foo.txt", 1), QDir::toNativeSeparators("C:\\bar"));
+#endif
+    }
 };
 
 QTEST_GUILESS_MAIN(FileSystemTest)
diff --git a/tests/INIFile_test.cpp b/tests/INIFile_test.cpp
index b64b031b..4be8133c 100644
--- a/tests/INIFile_test.cpp
+++ b/tests/INIFile_test.cpp
@@ -1,7 +1,11 @@
 #include <QTest>
 
+#include <QList>
+#include <QVariant>
 #include <settings/INIFile.h>
 
+#include <QVariantUtils.h>
+
 class IniFileTest : public QObject
 {
     Q_OBJECT
@@ -27,15 +31,6 @@ slots:
         QTest::newRow("Escape sequences 2") << "\"\n\n\"";
         QTest::newRow("Hashtags") << "some data#something";
     }
-    void test_Escape()
-    {
-        QFETCH(QString, through);
-
-        QString there = INIFile::escape(through);
-        QString back = INIFile::unescape(there);
-
-        QCOMPARE(back, through);
-    }
 
     void test_SaveLoad()
     {
@@ -52,8 +47,37 @@ slots:
         // load
         INIFile f2;
         f2.loadFile(filename);
-        QCOMPARE(a, f2.get("a","NOT SET").toString());
-        QCOMPARE(b, f2.get("b","NOT SET").toString());
+        QCOMPARE(f2.get("a","NOT SET").toString(), a);
+        QCOMPARE(f2.get("b","NOT SET").toString(), b);
+    }
+
+    void test_SaveLoadLists()
+    {
+        QString slist_strings = "(\"a\",\"b\",\"c\")";
+        QStringList list_strings = {"a", "b", "c"};
+
+        QString slist_numbers = "(1,2,3,10)";
+        QList<int> list_numbers = {1, 2, 3, 10};
+
+        QString filename = "test_SaveLoadLists.ini";
+
+        INIFile f;
+        f.set("list_strings", list_strings);
+        f.set("list_numbers", QVariantUtils::fromList(list_numbers));
+        f.saveFile(filename);
+
+        // load
+        INIFile f2;
+        f2.loadFile(filename);
+
+        QStringList out_list_strings = f2.get("list_strings", QStringList()).toStringList();
+        qDebug() << "OutStringList" << out_list_strings;
+        
+        QList<int> out_list_numbers = QVariantUtils::toList<int>(f2.get("list_numbers", QVariantUtils::fromList(QList<int>())));
+        qDebug() << "OutNumbersList" << out_list_numbers;
+
+        QCOMPARE(out_list_strings, list_strings);
+        QCOMPARE(out_list_numbers, list_numbers);
     }
 };
 
diff --git a/tests/Packwiz_test.cpp b/tests/Packwiz_test.cpp
index 098e8f89..29289469 100644
--- a/tests/Packwiz_test.cpp
+++ b/tests/Packwiz_test.cpp
@@ -48,7 +48,7 @@ class PackwizTest : public QObject {
         QCOMPARE(metadata.hash_format, "sha512");
         QCOMPARE(metadata.hash, "c8fe6e15ddea32668822dddb26e1851e5f03834be4bcb2eff9c0da7fdc086a9b6cead78e31a44d3bc66335cba11144ee0337c6d5346f1ba63623064499b3188d");
 
-        QCOMPARE(metadata.provider, ModPlatform::Provider::MODRINTH);
+        QCOMPARE(metadata.provider, ModPlatform::ResourceProvider::MODRINTH);
         QCOMPARE(metadata.version(), "ug2qKTPR");
         QCOMPARE(metadata.mod_id(), "kYq5qkSL");
    }
@@ -76,7 +76,7 @@ class PackwizTest : public QObject {
         QCOMPARE(metadata.hash_format, "murmur2");
         QCOMPARE(metadata.hash, "1781245820");
 
-        QCOMPARE(metadata.provider, ModPlatform::Provider::FLAME);
+        QCOMPARE(metadata.provider, ModPlatform::ResourceProvider::FLAME);
         QCOMPARE(metadata.file_id, 3509043);
         QCOMPARE(metadata.project_id, 327154);
     }
diff --git a/tests/ResourceFolderModel_test.cpp b/tests/ResourceFolderModel_test.cpp
index e38b8e93..962d89f1 100644
--- a/tests/ResourceFolderModel_test.cpp
+++ b/tests/ResourceFolderModel_test.cpp
@@ -36,6 +36,7 @@
 #include <QTest>
 #include <QTemporaryDir>
 #include <QTimer>
+#include "BaseInstance.h"
 
 #include <FileSystem.h>
 
@@ -89,7 +90,7 @@ slots:
 
             QEventLoop loop;
 
-            ModFolderModel m(tempDir.path(), true);
+            ModFolderModel m(tempDir.path(), nullptr, true);
 
             connect(&m, &ModFolderModel::updateFinished, &loop, &QEventLoop::quit);
 
@@ -113,7 +114,7 @@ slots:
             QString folder = source + '/';
             QTemporaryDir tempDir;
             QEventLoop loop;
-            ModFolderModel m(tempDir.path(), true);
+            ModFolderModel m(tempDir.path(), nullptr, true);
 
             connect(&m, &ModFolderModel::updateFinished, &loop, &QEventLoop::quit);
 
@@ -136,8 +137,7 @@ slots:
     void test_addFromWatch()
     {
         QString source = QFINDTESTDATA("testdata/ResourceFolderModel");
-
-        ModFolderModel model(source);
+        ModFolderModel model(source, nullptr);
 
         QCOMPARE(model.size(), 0);
 
@@ -157,8 +157,7 @@ slots:
         QString file_mod = QFINDTESTDATA("testdata/ResourceFolderModel/supercoolmod.jar");
 
         QTemporaryDir tmp;
-
-        ResourceFolderModel model(QDir(tmp.path()));
+        ResourceFolderModel model(QDir(tmp.path()), nullptr);
 
         QCOMPARE(model.size(), 0);
 
@@ -209,7 +208,7 @@ slots:
         QString file_mod = QFINDTESTDATA("testdata/ResourceFolderModel/supercoolmod.jar");
 
         QTemporaryDir tmp;
-        ResourceFolderModel model(tmp.path());
+        ResourceFolderModel model(tmp.path(), nullptr);
 
         QCOMPARE(model.size(), 0);
 
diff --git a/tests/ResourceModel_test.cpp b/tests/ResourceModel_test.cpp
new file mode 100644
index 00000000..c0d9cd95
--- /dev/null
+++ b/tests/ResourceModel_test.cpp
@@ -0,0 +1,88 @@
+#include <QAbstractItemModelTester>
+#include <QTest>
+#include <QTimer>
+
+#include <Json.h>
+
+#include <ui/pages/modplatform/ResourceModel.h>
+
+#include "DummyResourceAPI.h"
+
+using ResourceDownload::ResourceModel;
+
+#define EXEC_TASK(EXEC)                                                                 \
+    QEventLoop loop;                                                                    \
+                                                                                        \
+    connect(model, &ResourceModel::dataChanged, &loop, &QEventLoop::quit);              \
+                                                                                        \
+    QTimer expire_timer;                                                                \
+    expire_timer.callOnTimeout(&loop, &QEventLoop::quit);                               \
+    expire_timer.setSingleShot(true);                                                   \
+    expire_timer.start(4000);                                                           \
+                                                                                        \
+    EXEC;                                                                               \
+    if (model->hasActiveSearchJob())                                                    \
+        loop.exec();                                                                    \
+                                                                                        \
+    QVERIFY2(expire_timer.isActive(), "Timer has expired. The search never finished."); \
+    expire_timer.stop();                                                                \
+                                                                                        \
+    disconnect(model, nullptr, &loop, nullptr)
+
+class ResourceModelTest;
+
+class DummyResourceModel : public ResourceModel {
+    Q_OBJECT
+
+    friend class ResourceModelTest;
+
+   public:
+    DummyResourceModel() : ResourceModel(new DummyResourceAPI) {}
+
+    [[nodiscard]] auto metaEntryBase() const -> QString override { return ""; };
+
+    ResourceAPI::SearchArgs createSearchArguments() override { return {}; };
+    ResourceAPI::VersionSearchArgs createVersionsArguments(QModelIndex&) override { return {}; };
+    ResourceAPI::ProjectInfoArgs createInfoArguments(QModelIndex&) override { return {}; };
+
+    QJsonArray documentToArray(QJsonDocument& doc) const override { return doc.object().value("hits").toArray(); }
+
+    void loadIndexedPack(ModPlatform::IndexedPack& pack, QJsonObject& obj) override
+    {
+        pack.authors.append({ Json::requireString(obj, "author") });
+        pack.description = Json::requireString(obj, "description");
+        pack.addonId = Json::requireString(obj, "project_id");
+    }
+};
+
+class ResourceModelTest : public QObject {
+    Q_OBJECT
+   private slots:
+    void test_abstract_item_model() { [[maybe_unused]] auto tester = new QAbstractItemModelTester(new DummyResourceModel); }
+
+    void test_search()
+    {
+        auto model = new DummyResourceModel;
+
+        QVERIFY(model->m_packs.isEmpty());
+
+        EXEC_TASK(model->search());
+
+        QVERIFY(model->m_packs.size() == 1);
+        QVERIFY(model->m_search_state == DummyResourceModel::SearchState::Finished);
+
+        auto processed_pack = model->m_packs.at(0);
+        auto search_json = DummyResourceAPI::searchRequestResult();
+        auto processed_response = model->documentToArray(search_json).first().toObject();
+
+        QVERIFY(processed_pack->addonId.toString() == Json::requireString(processed_response, "project_id"));
+        QVERIFY(processed_pack->description == Json::requireString(processed_response, "description"));
+        QVERIFY(processed_pack->authors.first().name == Json::requireString(processed_response, "author"));
+    }
+};
+
+QTEST_GUILESS_MAIN(ResourceModelTest)
+
+#include "ResourceModel_test.moc"
+
+#include "moc_DummyResourceAPI.cpp"
diff --git a/tests/ResourcePackParse_test.cpp b/tests/ResourcePackParse_test.cpp
index 568c3b63..7f2f86bf 100644
--- a/tests/ResourcePackParse_test.cpp
+++ b/tests/ResourcePackParse_test.cpp
@@ -35,10 +35,11 @@ class ResourcePackParseTest : public QObject {
         QString zip_rp = FS::PathCombine(source, "test_resource_pack_idk.zip");
         ResourcePack pack { QFileInfo(zip_rp) };
 
-        ResourcePackUtils::processZIP(pack);
+        bool valid = ResourcePackUtils::processZIP(pack, ResourcePackUtils::ProcessingLevel::BasicInfoOnly);
 
         QVERIFY(pack.packFormat() == 3);
         QVERIFY(pack.description() == "um dois, feijão com arroz, três quatro, feijão no prato, cinco seis, café inglês, sete oito, comer biscoito, nove dez comer pastéis!!");
+        QVERIFY(valid == true);
     }
 
     void test_parseFolder()
@@ -48,10 +49,11 @@ class ResourcePackParseTest : public QObject {
         QString folder_rp = FS::PathCombine(source, "test_folder");
         ResourcePack pack { QFileInfo(folder_rp) };
 
-        ResourcePackUtils::processFolder(pack);
+        bool valid = ResourcePackUtils::processFolder(pack, ResourcePackUtils::ProcessingLevel::BasicInfoOnly);
 
         QVERIFY(pack.packFormat() == 1);
         QVERIFY(pack.description() == "Some resource pack maybe");
+        QVERIFY(valid == true);
     }
 
     void test_parseFolder2()
@@ -61,10 +63,11 @@ class ResourcePackParseTest : public QObject {
         QString folder_rp = FS::PathCombine(source, "another_test_folder");
         ResourcePack pack { QFileInfo(folder_rp) };
 
-        ResourcePackUtils::process(pack);
+        bool valid = ResourcePackUtils::process(pack, ResourcePackUtils::ProcessingLevel::BasicInfoOnly);
 
         QVERIFY(pack.packFormat() == 6);
         QVERIFY(pack.description() == "o quartel pegou fogo, policia deu sinal, acode acode acode a bandeira nacional");
+        QVERIFY(valid == false); // no assets dir
     }
 };
 
diff --git a/tests/ShaderPackParse_test.cpp b/tests/ShaderPackParse_test.cpp
new file mode 100644
index 00000000..7df105c6
--- /dev/null
+++ b/tests/ShaderPackParse_test.cpp
@@ -0,0 +1,77 @@
+
+// SPDX-FileCopyrightText: 2022 Rachel Powers <508861+Ryex@users.noreply.github.com>
+//
+// SPDX-License-Identifier: GPL-3.0-only
+
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2022 Rachel Powers <508861+Ryex@users.noreply.github.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QTest>
+#include <QTimer>
+
+#include <FileSystem.h>
+
+#include <minecraft/mod/ShaderPack.h>
+#include <minecraft/mod/tasks/LocalShaderPackParseTask.h>
+
+class ShaderPackParseTest : public QObject {
+    Q_OBJECT
+
+    private slots:
+    void test_parseZIP()
+    {
+        QString source = QFINDTESTDATA("testdata/ShaderPackParse");
+
+        QString zip_sp = FS::PathCombine(source, "shaderpack1.zip");
+        ShaderPack pack { QFileInfo(zip_sp) };
+
+        bool valid = ShaderPackUtils::processZIP(pack);
+
+        QVERIFY(pack.packFormat() == ShaderPackFormat::VALID);
+        QVERIFY(valid == true);
+    }
+
+    void test_parseFolder()
+    {
+        QString source = QFINDTESTDATA("testdata/ShaderPackParse");
+
+        QString folder_sp = FS::PathCombine(source, "shaderpack2");
+        ShaderPack pack { QFileInfo(folder_sp) };
+
+        bool valid = ShaderPackUtils::processFolder(pack);
+
+        QVERIFY(pack.packFormat() == ShaderPackFormat::VALID);
+        QVERIFY(valid == true);
+    }
+
+    void test_parseZIP2()
+    {
+        QString source = QFINDTESTDATA("testdata/ShaderPackParse");
+
+        QString folder_sp = FS::PathCombine(source, "shaderpack3.zip");
+        ShaderPack pack { QFileInfo(folder_sp) };
+
+        bool valid = ShaderPackUtils::process(pack);
+
+        QVERIFY(pack.packFormat() == ShaderPackFormat::INVALID);
+        QVERIFY(valid == false);
+    }
+};
+
+QTEST_GUILESS_MAIN(ShaderPackParseTest)
+
+#include "ShaderPackParse_test.moc"
diff --git a/tests/Task_test.cpp b/tests/Task_test.cpp
index 80bba02f..dabe5da2 100644
--- a/tests/Task_test.cpp
+++ b/tests/Task_test.cpp
@@ -1,16 +1,23 @@
 #include <QTest>
+#include <QTimer>
+#include <QThread>
 
 #include <tasks/ConcurrentTask.h>
 #include <tasks/MultipleOptionsTask.h>
 #include <tasks/SequentialTask.h>
 #include <tasks/Task.h>
 
+#include <array>
+
 /* Does nothing. Only used for testing. */
 class BasicTask : public Task {
     Q_OBJECT
 
     friend class TaskTest;
 
+   public:
+    BasicTask(bool show_debug_log = true) : Task(nullptr, show_debug_log) {}
+
    private:
     void executeTask() override
     {
@@ -30,6 +37,58 @@ class BasicTask_MultiStep : public Task {
     void executeTask() override {};   
 };
 
+class BigConcurrentTask : public ConcurrentTask {
+    Q_OBJECT
+
+    void startNext() override
+    {
+        // 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 {};
+
+        ConcurrentTask::startNext();
+    }
+};
+
+class BigConcurrentTaskThread : public QThread {
+    Q_OBJECT
+
+    BigConcurrentTask big_task;
+
+    void run() override
+    {
+        QTimer deadline;
+        deadline.setInterval(10000);
+        connect(&deadline, &QTimer::timeout, this, [this]{ passed_the_deadline = true; });
+        deadline.start();
+
+        // 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();
+
+        while (!big_task.isFinished() && !passed_the_deadline)
+            QCoreApplication::processEvents();
+
+        emit finished();
+    }
+
+   public:
+    bool passed_the_deadline = false;
+
+   signals:
+    void finished();
+};
+
 class TaskTest : public QObject {
     Q_OBJECT
 
@@ -41,7 +100,7 @@ class TaskTest : public QObject {
         t.setStatus(status);
 
         QCOMPARE(t.getStatus(), status);
-        QCOMPARE(t.getStepStatus(), status);
+        QCOMPARE(t.getStepProgress().isEmpty(), TaskStepProgressList{}.isEmpty());
     }
 
     void test_SetStatus_MultiStep(){
@@ -53,7 +112,7 @@ class TaskTest : public QObject {
         QCOMPARE(t.getStatus(), status);
         // Even though it is multi step, it does not override the getStepStatus method,
         // so it should remain the same.
-        QCOMPARE(t.getStepStatus(), status);
+        QCOMPARE(t.getStepProgress().isEmpty(), TaskStepProgressList{}.isEmpty());
     }
 
     void test_SetProgress(){
@@ -78,21 +137,21 @@ class TaskTest : public QObject {
     }
 
     void test_basicConcurrentRun(){
-        BasicTask t1;
-        BasicTask t2;
-        BasicTask t3;
+        auto t1 = makeShared<BasicTask>();
+        auto t2 = makeShared<BasicTask>();
+        auto t3 = makeShared<BasicTask>();
 
         ConcurrentTask t;
 
-        t.addTask(&t1);
-        t.addTask(&t2);
-        t.addTask(&t3);
+        t.addTask(t1);
+        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());
+                QVERIFY(t1->wasSuccessful());
+                QVERIFY(t2->wasSuccessful());
+                QVERIFY(t3->wasSuccessful());
         });
 
         t.start();
@@ -103,31 +162,39 @@ class TaskTest : public QObject {
 
     // Tests if starting new tasks after the 6 initial ones is working
     void test_moreConcurrentRun(){
-        BasicTask t1, t2, t3, t4, t5, t6, t7, t8, t9;
+        auto t1 = makeShared<BasicTask>();
+        auto t2 = makeShared<BasicTask>();
+        auto t3 = makeShared<BasicTask>();
+        auto t4 = makeShared<BasicTask>();
+        auto t5 = makeShared<BasicTask>();
+        auto t6 = makeShared<BasicTask>();
+        auto t7 = makeShared<BasicTask>();
+        auto t8 = makeShared<BasicTask>();
+        auto t9 = makeShared<BasicTask>();
 
         ConcurrentTask t;
 
-        t.addTask(&t1);
-        t.addTask(&t2);
-        t.addTask(&t3);
-        t.addTask(&t4);
-        t.addTask(&t5);
-        t.addTask(&t6);
-        t.addTask(&t7);
-        t.addTask(&t8);
-        t.addTask(&t9);
+        t.addTask(t1);
+        t.addTask(t2);
+        t.addTask(t3);
+        t.addTask(t4);
+        t.addTask(t5);
+        t.addTask(t6);
+        t.addTask(t7);
+        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());
+                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();
@@ -137,21 +204,21 @@ class TaskTest : public QObject {
     }
 
     void test_basicSequentialRun(){
-        BasicTask t1;
-        BasicTask t2;
-        BasicTask t3;
+        auto t1 = makeShared<BasicTask>();
+        auto t2 = makeShared<BasicTask>();
+        auto t3 = makeShared<BasicTask>();
 
         SequentialTask t;
 
-        t.addTask(&t1);
-        t.addTask(&t2);
-        t.addTask(&t3);
+        t.addTask(t1);
+        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());
+                QVERIFY(t1->wasSuccessful());
+                QVERIFY(t2->wasSuccessful());
+                QVERIFY(t3->wasSuccessful());
         });
 
         t.start();
@@ -161,21 +228,21 @@ class TaskTest : public QObject {
     }
 
     void test_basicMultipleOptionsRun(){
-        BasicTask t1;
-        BasicTask t2;
-        BasicTask t3;
+        auto t1 = makeShared<BasicTask>();
+        auto t2 = makeShared<BasicTask>();
+        auto t3 = makeShared<BasicTask>();
 
         MultipleOptionsTask t;
 
-        t.addTask(&t1);
-        t.addTask(&t2);
-        t.addTask(&t3);
+        t.addTask(t1);
+        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());
+                QVERIFY(t1->wasSuccessful());
+                QVERIFY(!t2->wasSuccessful());
+                QVERIFY(!t3->wasSuccessful());
         });
 
         t.start();
@@ -183,6 +250,22 @@ class TaskTest : public QObject {
             return t.isFinished();
         }, 1000), "Task didn't finish as it should.");
     }
+
+    void test_stackOverflowInConcurrentTask()
+    {
+        QEventLoop loop;
+
+        auto thread = new BigConcurrentTaskThread;
+
+        connect(thread, &BigConcurrentTaskThread::finished, &loop, &QEventLoop::quit);
+
+        thread->start();
+
+        loop.exec();
+
+        QVERIFY(!thread->passed_the_deadline);
+        thread->deleteLater();
+    }
 };
 
 QTEST_GUILESS_MAIN(TaskTest)
diff --git a/tests/TexturePackParse_test.cpp b/tests/TexturePackParse_test.cpp
index 0771f79f..4ddc0a3a 100644
--- a/tests/TexturePackParse_test.cpp
+++ b/tests/TexturePackParse_test.cpp
@@ -36,9 +36,10 @@ class TexturePackParseTest : public QObject {
         QString zip_rp = FS::PathCombine(source, "test_texture_pack_idk.zip");
         TexturePack pack { QFileInfo(zip_rp) };
 
-        TexturePackUtils::processZIP(pack);
+        bool valid = TexturePackUtils::processZIP(pack);
 
         QVERIFY(pack.description() == "joe biden, wake up");
+        QVERIFY(valid == true);
     }
 
     void test_parseFolder()
@@ -48,9 +49,10 @@ class TexturePackParseTest : public QObject {
         QString folder_rp = FS::PathCombine(source, "test_texturefolder");
         TexturePack pack { QFileInfo(folder_rp) };
 
-        TexturePackUtils::processFolder(pack);
+        bool valid = TexturePackUtils::processFolder(pack, TexturePackUtils::ProcessingLevel::BasicInfoOnly);
 
         QVERIFY(pack.description() == "Some texture pack surely");
+        QVERIFY(valid == true);
     }
 
     void test_parseFolder2()
@@ -60,9 +62,10 @@ class TexturePackParseTest : public QObject {
         QString folder_rp = FS::PathCombine(source, "another_test_texturefolder");
         TexturePack pack { QFileInfo(folder_rp) };
 
-        TexturePackUtils::process(pack);
+        bool valid = TexturePackUtils::process(pack, TexturePackUtils::ProcessingLevel::BasicInfoOnly);
 
         QVERIFY(pack.description() == "quieres\nfor real");
+        QVERIFY(valid == true);
     }
 };
 
diff --git a/tests/Version_test.cpp b/tests/Version_test.cpp
index 734528b7..afb4c610 100644
--- a/tests/Version_test.cpp
+++ b/tests/Version_test.cpp
@@ -15,56 +15,130 @@
 
 #include <QTest>
 
-#include <TestUtil.h>
 #include <Version.h>
 
-class ModUtilsTest : public QObject
-{
+class VersionTest : public QObject {
     Q_OBJECT
-    void setupVersions()
+
+    void addDataColumns()
     {
         QTest::addColumn<QString>("first");
         QTest::addColumn<QString>("second");
         QTest::addColumn<bool>("lessThan");
         QTest::addColumn<bool>("equal");
+    }
+
+    void setupVersions()
+    {
+        addDataColumns();
 
         QTest::newRow("equal, explicit") << "1.2.0" << "1.2.0" << false << true;
-        QTest::newRow("equal, implicit 1") << "1.2" << "1.2.0" << false << true;
-        QTest::newRow("equal, implicit 2") << "1.2.0" << "1.2" << false << true;
         QTest::newRow("equal, two-digit") << "1.42" << "1.42" << false << true;
 
         QTest::newRow("lessThan, explicit 1") << "1.2.0" << "1.2.1" << true << false;
         QTest::newRow("lessThan, explicit 2") << "1.2.0" << "1.3.0" << true << false;
         QTest::newRow("lessThan, explicit 3") << "1.2.0" << "2.2.0" << true << false;
-        QTest::newRow("lessThan, implicit 1") << "1.2" << "1.2.1" << true << false;
-        QTest::newRow("lessThan, implicit 2") << "1.2" << "1.3.0" << true << false;
-        QTest::newRow("lessThan, implicit 3") << "1.2" << "2.2.0" << true << false;
+        QTest::newRow("lessThan, implicit 1") << "1.2" << "1.2.0" << true << false;
+        QTest::newRow("lessThan, implicit 2") << "1.2" << "1.2.1" << true << false;
+        QTest::newRow("lessThan, implicit 3") << "1.2" << "1.3.0" << true << false;
+        QTest::newRow("lessThan, implicit 4") << "1.2" << "2.2.0" << true << false;
         QTest::newRow("lessThan, two-digit") << "1.41" << "1.42" << true << false;
 
         QTest::newRow("greaterThan, explicit 1") << "1.2.1" << "1.2.0" << false << false;
         QTest::newRow("greaterThan, explicit 2") << "1.3.0" << "1.2.0" << false << false;
         QTest::newRow("greaterThan, explicit 3") << "2.2.0" << "1.2.0" << false << false;
-        QTest::newRow("greaterThan, implicit 1") << "1.2.1" << "1.2" << false << false;
-        QTest::newRow("greaterThan, implicit 2") << "1.3.0" << "1.2" << false << false;
-        QTest::newRow("greaterThan, implicit 3") << "2.2.0" << "1.2" << false << false;
+        QTest::newRow("greaterThan, implicit 1") << "1.2.0" << "1.2" << false << false;
+        QTest::newRow("greaterThan, implicit 2") << "1.2.1" << "1.2" << false << false;
+        QTest::newRow("greaterThan, implicit 3") << "1.3.0" << "1.2" << false << false;
+        QTest::newRow("greaterThan, implicit 4") << "2.2.0" << "1.2" << false << false;
         QTest::newRow("greaterThan, two-digit") << "1.42" << "1.41" << false << false;
     }
 
-private slots:
-    void initTestCase()
+   private slots:
+    void test_versionCompare_data()
     {
-
+        setupVersions();
     }
-    void cleanupTestCase()
+
+    void test_versionCompare()
     {
+        QFETCH(QString, first);
+        QFETCH(QString, second);
+        QFETCH(bool, lessThan);
+        QFETCH(bool, equal);
 
+        const auto v1 = Version(first);
+        const auto v2 = Version(second);
+
+        qDebug() << v1 << "vs" << v2;
+
+        QCOMPARE(v1 < v2, lessThan);
+        QCOMPARE(v1 > v2, !lessThan && !equal);
+        QCOMPARE(v1 == v2, equal);
     }
 
-    void test_versionCompare_data()
+    void test_flexVerTestVector_data()
     {
-        setupVersions();
+        addDataColumns();
+
+        QDir test_vector_dir(QFINDTESTDATA("testdata/Version"));
+
+        QFile vector_file{test_vector_dir.absoluteFilePath("test_vectors.txt")};
+
+        vector_file.open(QFile::OpenModeFlag::ReadOnly);
+
+        int test_number = 0;
+        const QString test_name_template { "FlexVer test #%1 (%2)" };
+        for (auto line = vector_file.readLine(); !vector_file.atEnd(); line = vector_file.readLine()) {
+            line = line.simplified();
+            if (line.startsWith('#') || line.isEmpty())
+                continue;
+
+            test_number += 1;
+
+            auto split_line = line.split('<');
+            if (split_line.size() == 2) {
+                QString first{split_line.first().simplified()};
+                QString second{split_line.last().simplified()};
+
+                auto new_test_name = test_name_template.arg(QString::number(test_number), "lessThan").toLatin1().data();
+                QTest::newRow(new_test_name) << first << second << true << false;
+
+                continue;
+            }
+
+            split_line = line.split('=');
+            if (split_line.size() == 2) {
+                QString first{split_line.first().simplified()};
+                QString second{split_line.last().simplified()};
+
+                auto new_test_name = test_name_template.arg(QString::number(test_number), "equals").toLatin1().data();
+                QTest::newRow(new_test_name) << first << second << false << true;
+
+                continue;
+            }
+
+            split_line = line.split('>');
+            if (split_line.size() == 2) {
+                QString first{split_line.first().simplified()};
+                QString second{split_line.last().simplified()};
+
+                auto new_test_name = test_name_template.arg(QString::number(test_number), "greaterThan").toLatin1().data();
+                QTest::newRow(new_test_name) << first << second << false << false;
+
+                continue;
+            }
+
+            qCritical() << "Unexpected separator in the test vector: ";
+            qCritical() << line;
+
+            QVERIFY(0 != 0);
+        }
+
+        vector_file.close();
     }
-    void test_versionCompare()
+
+    void test_flexVerTestVector()
     {
         QFETCH(QString, first);
         QFETCH(QString, second);
@@ -74,12 +148,14 @@ private slots:
         const auto v1 = Version(first);
         const auto v2 = Version(second);
 
+        qDebug() << v1 << "vs" << v2;
+
         QCOMPARE(v1 < v2, lessThan);
         QCOMPARE(v1 > v2, !lessThan && !equal);
         QCOMPARE(v1 == v2, equal);
     }
 };
 
-QTEST_GUILESS_MAIN(ModUtilsTest)
+QTEST_GUILESS_MAIN(VersionTest)
 
 #include "Version_test.moc"
diff --git a/tests/WorldSaveParse_test.cpp b/tests/WorldSaveParse_test.cpp
new file mode 100644
index 00000000..4a8c3d29
--- /dev/null
+++ b/tests/WorldSaveParse_test.cpp
@@ -0,0 +1,94 @@
+
+// SPDX-FileCopyrightText: 2022 Rachel Powers <508861+Ryex@users.noreply.github.com>
+//
+// SPDX-License-Identifier: GPL-3.0-only
+
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (C) 2022 Rachel Powers <508861+Ryex@users.noreply.github.com>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, version 3.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <QTest>
+#include <QTimer>
+
+#include <FileSystem.h>
+
+#include <minecraft/mod/WorldSave.h>
+#include <minecraft/mod/tasks/LocalWorldSaveParseTask.h>
+
+class WorldSaveParseTest : public QObject {
+    Q_OBJECT
+
+    private slots:
+    void test_parseZIP()
+    {
+        QString source = QFINDTESTDATA("testdata/WorldSaveParse");
+
+        QString zip_ws = FS::PathCombine(source, "minecraft_save_1.zip") ;
+        WorldSave save { QFileInfo(zip_ws) };
+
+        bool valid = WorldSaveUtils::processZIP(save);
+
+        QVERIFY(save.saveFormat() == WorldSaveFormat::SINGLE);
+        QVERIFY(save.saveDirName() == "world_1");
+        QVERIFY(valid == true);
+    }
+  
+    void test_parse_ZIP2()
+    {
+        QString source = QFINDTESTDATA("testdata/WorldSaveParse");
+
+        QString zip_ws = FS::PathCombine(source, "minecraft_save_2.zip") ;
+        WorldSave save { QFileInfo(zip_ws) };
+
+        bool valid = WorldSaveUtils::processZIP(save);
+
+        QVERIFY(save.saveFormat() == WorldSaveFormat::MULTI);
+        QVERIFY(save.saveDirName() == "world_2");
+        QVERIFY(valid == true);
+    }
+  
+    void test_parseFolder()
+    {
+        QString source = QFINDTESTDATA("testdata/WorldSaveParse");
+
+        QString folder_ws = FS::PathCombine(source, "minecraft_save_3");
+        WorldSave save { QFileInfo(folder_ws) };
+
+        bool valid = WorldSaveUtils::processFolder(save);
+
+        QVERIFY(save.saveFormat() == WorldSaveFormat::SINGLE);
+        QVERIFY(save.saveDirName() == "world_3");
+        QVERIFY(valid == true);
+    }
+
+    void test_parseFolder2()
+    {
+        QString source = QFINDTESTDATA("testdata/WorldSaveParse");
+
+        QString folder_ws = FS::PathCombine(source, "minecraft_save_4");
+        WorldSave save { QFileInfo(folder_ws) };
+
+        bool valid = WorldSaveUtils::process(save);
+
+        QVERIFY(save.saveFormat() == WorldSaveFormat::MULTI);
+        QVERIFY(save.saveDirName() == "world_4");
+        QVERIFY(valid == true);
+    }
+};
+
+QTEST_GUILESS_MAIN(WorldSaveParseTest)
+
+#include "WorldSaveParse_test.moc"
diff --git a/tests/testdata/DataPackParse/another_test_folder/data/dummy/tags/item/foo_proof/bar.json b/tests/testdata/DataPackParse/another_test_folder/data/dummy/tags/item/foo_proof/bar.json
new file mode 100644
index 00000000..9e26dfee
--- /dev/null
+++ b/tests/testdata/DataPackParse/another_test_folder/data/dummy/tags/item/foo_proof/bar.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/tests/testdata/DataPackParse/another_test_folder/pack.mcmeta b/tests/testdata/DataPackParse/another_test_folder/pack.mcmeta
new file mode 100644
index 00000000..5509d007
--- /dev/null
+++ b/tests/testdata/DataPackParse/another_test_folder/pack.mcmeta
@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "pack_format": 6,
+    "description": "Some data pack three, leaves on the tree"
+  }
+}
diff --git a/tests/testdata/DataPackParse/test_data_pack_boogaloo.zip b/tests/testdata/DataPackParse/test_data_pack_boogaloo.zip
new file mode 100644
index 00000000..cb0b9f3c
--- /dev/null
+++ b/tests/testdata/DataPackParse/test_data_pack_boogaloo.zip
diff --git a/tests/testdata/DataPackParse/test_folder/data/dummy/tags/item/foo_proof/bar.json b/tests/testdata/DataPackParse/test_folder/data/dummy/tags/item/foo_proof/bar.json
new file mode 100644
index 00000000..9e26dfee
--- /dev/null
+++ b/tests/testdata/DataPackParse/test_folder/data/dummy/tags/item/foo_proof/bar.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/tests/testdata/DataPackParse/test_folder/pack.mcmeta b/tests/testdata/DataPackParse/test_folder/pack.mcmeta
new file mode 100644
index 00000000..dbfc7e9b
--- /dev/null
+++ b/tests/testdata/DataPackParse/test_folder/pack.mcmeta
@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "pack_format": 10,
+    "description": "Some data pack, maybe"
+  }
+}
diff --git a/tests/testdata/ResourcePackParse/test_resource_pack_idk.zip b/tests/testdata/ResourcePackParse/test_resource_pack_idk.zip
index 52b91cdc..b4e66a60 100644
--- a/tests/testdata/ResourcePackParse/test_resource_pack_idk.zip
+++ b/tests/testdata/ResourcePackParse/test_resource_pack_idk.zip
diff --git a/tests/testdata/ShaderPackParse/shaderpack1.zip b/tests/testdata/ShaderPackParse/shaderpack1.zip
new file mode 100644
index 00000000..9a8fb186
--- /dev/null
+++ b/tests/testdata/ShaderPackParse/shaderpack1.zip
diff --git a/tests/testdata/ShaderPackParse/shaderpack2/shaders/shaders.properties b/tests/testdata/ShaderPackParse/shaderpack2/shaders/shaders.properties
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/tests/testdata/ShaderPackParse/shaderpack2/shaders/shaders.properties
diff --git a/tests/testdata/ShaderPackParse/shaderpack3.zip b/tests/testdata/ShaderPackParse/shaderpack3.zip
new file mode 100644
index 00000000..dbec042d
--- /dev/null
+++ b/tests/testdata/ShaderPackParse/shaderpack3.zip
diff --git a/tests/testdata/Version/test_vectors.txt b/tests/testdata/Version/test_vectors.txt
new file mode 100644
index 00000000..e6c6507c
--- /dev/null
+++ b/tests/testdata/Version/test_vectors.txt
@@ -0,0 +1,63 @@
+# Test vector from:
+# https://github.com/unascribed/FlexVer/blob/704e12759b6e59220ff888f8bf2ec15b8f8fd969/test/test_vectors.txt
+#
+# This test file is formatted as "<lefthand> <operator> <righthand>", seperated by the space character
+# Implementations should ignore lines starting with "#" and lines that have a length of 0
+
+# Basic numeric ordering (lexical string sort fails these)
+10 > 2
+100 > 10
+
+# Trivial common numerics
+1.0 < 1.1
+1.0 < 1.0.1
+1.1 > 1.0.1
+
+# SemVer compatibility
+1.5 > 1.5-pre1
+1.5 = 1.5+foobar
+
+# SemVer incompatibility
+1.5 < 1.5-2
+1.5-pre10 > 1.5-pre2
+
+# Empty strings
+ = 
+1 > 
+ < 1
+
+# Check boundary between textual and prerelease
+a-a < a
+
+# Check boundary between textual and appendix
+a+a = a
+
+# Dash is included in prerelease comparison (if stripped it will be a smaller component)
+# Note that a-a < a=a regardless since the prerelease splits the component creating a smaller first component; 0 is added to force splitting regardless
+a0-a < a0=a
+
+# Pre-releases must contain only non-digit
+1.16.5-10 > 1.16.5
+
+# Pre-releases can have multiple dashes (should not be split)
+# Reasoning for test data: "p-a!" > "p-a-" (correct); "p-a!" < "p-a t-" (what happens if every dash creates a new component)
+-a- > -a!
+
+# Misc
+b1.7.3 > a1.2.6
+b1.2.6 > a1.7.3
+a1.1.2 < a1.1.2_01
+1.16.5-0.00.5 > 1.14.2-1.3.7
+1.0.0 < 1.0.0_01
+1.0.1 > 1.0.0_01
+1.0.0_01 < 1.0.1
+0.17.1-beta.1 < 0.17.1
+0.17.1-beta.1 < 0.17.1-beta.2
+1.4.5_01 = 1.4.5_01+fabric-1.17
+1.4.5_01 = 1.4.5_01+fabric-1.17+ohgod
+14w16a < 18w40b
+18w40a < 18w40b
+1.4.5_01+fabric-1.17 < 18w40b
+13w02a < c0.3.0_01
+0.6.0-1.18.x < 0.9.beta-1.18.x
+
diff --git a/tests/testdata/WorldSaveParse/minecraft_save_1.zip b/tests/testdata/WorldSaveParse/minecraft_save_1.zip
new file mode 100644
index 00000000..832a243d
--- /dev/null
+++ b/tests/testdata/WorldSaveParse/minecraft_save_1.zip
diff --git a/tests/testdata/WorldSaveParse/minecraft_save_2.zip b/tests/testdata/WorldSaveParse/minecraft_save_2.zip
new file mode 100644
index 00000000..6c895176
--- /dev/null
+++ b/tests/testdata/WorldSaveParse/minecraft_save_2.zip
diff --git a/tests/testdata/WorldSaveParse/minecraft_save_3/world_3/level.dat b/tests/testdata/WorldSaveParse/minecraft_save_3/world_3/level.dat
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/tests/testdata/WorldSaveParse/minecraft_save_3/world_3/level.dat
diff --git a/tests/testdata/WorldSaveParse/minecraft_save_4/saves/world_4/level.dat b/tests/testdata/WorldSaveParse/minecraft_save_4/saves/world_4/level.dat
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/tests/testdata/WorldSaveParse/minecraft_save_4/saves/world_4/level.dat