diff --git a/autotests/plugins/cli7zplugin/cli7ztest.cpp b/autotests/plugins/cli7zplugin/cli7ztest.cpp
index 30258cfc..f80a0d32 100644
--- a/autotests/plugins/cli7zplugin/cli7ztest.cpp
+++ b/autotests/plugins/cli7zplugin/cli7ztest.cpp
@@ -1,380 +1,389 @@
 /*
   * Copyright (c) 2016 Ragnar Thomsen <rthomsen6@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ( INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION ) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * ( INCLUDING NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "cli7ztest.h"
 
 #include <QFile>
 #include <QSignalSpy>
 #include <QTest>
 #include <QTextStream>
 
 #include <KPluginLoader>
 
 QTEST_GUILESS_MAIN(Cli7zTest)
 
 using namespace Kerfuffle;
 
 void Cli7zTest::initTestCase()
 {
     m_plugin = new Plugin(this);
     foreach (Plugin *plugin, m_pluginManger.availablePlugins()) {
         if (plugin->metaData().pluginId() == QStringLiteral("kerfuffle_cli7z")) {
             m_plugin = plugin;
             return;
         }
     }
 }
 
 void Cli7zTest::testArchive_data()
 {
     QTest::addColumn<QString>("archivePath");
     QTest::addColumn<QString>("expectedFileName");
     QTest::addColumn<bool>("isReadOnly");
     QTest::addColumn<bool>("isSingleFolder");
     QTest::addColumn<Archive::EncryptionType>("expectedEncryptionType");
     QTest::addColumn<QString>("expectedSubfolderName");
 
     QString archivePath = QFINDTESTDATA("data/one_toplevel_folder.7z");
     QTest::newRow("archive with one top-level folder")
             << archivePath
             << QFileInfo(archivePath).fileName()
             << false << true << Archive::Unencrypted
             << QStringLiteral("A");
 }
 
 void Cli7zTest::testArchive()
 {
     if (!m_plugin->isValid()) {
         QSKIP("cli7z plugin not available. Skipping test.", SkipSingle);
     }
 
     QFETCH(QString, archivePath);
     Archive *archive = Archive::create(archivePath, m_plugin, this);
     QVERIFY(archive);
 
     if (!archive->isValid()) {
         QSKIP("Could not load the cli7z plugin. Skipping test.", SkipSingle);
     }
 
     QFETCH(QString, expectedFileName);
     QCOMPARE(QFileInfo(archive->fileName()).fileName(), expectedFileName);
 
     QFETCH(bool, isReadOnly);
     QCOMPARE(archive->isReadOnly(), isReadOnly);
 
     QFETCH(bool, isSingleFolder);
     QCOMPARE(archive->isSingleFolderArchive(), isSingleFolder);
 
     QFETCH(Archive::EncryptionType, expectedEncryptionType);
     QCOMPARE(archive->encryptionType(), expectedEncryptionType);
 
     QFETCH(QString, expectedSubfolderName);
     QCOMPARE(archive->subfolderName(), expectedSubfolderName);
 }
 
 void Cli7zTest::testList_data()
 {
     QTest::addColumn<QString>("outputTextFile");
     QTest::addColumn<int>("expectedEntriesCount");
     // Index of some entry to be tested.
     QTest::addColumn<int>("someEntryIndex");
     // Entry metadata.
     QTest::addColumn<QString>("expectedName");
     QTest::addColumn<bool>("isDirectory");
     QTest::addColumn<bool>("isPasswordProtected");
     QTest::addColumn<qulonglong>("expectedSize");
     QTest::addColumn<QString>("expectedTimestamp");
 
     // p7zip version 15.14 tests
 
     QTest::newRow("normal-file-1514")
             << QFINDTESTDATA("data/archive-with-symlink-1514.txt") << 10
             << 4 << QStringLiteral("testarchive/dir2/file2.txt") << false << false << (qulonglong) 32 << QStringLiteral("2015-05-17T19:41:48");
 
     QTest::newRow("encrypted-1514")
             << QFINDTESTDATA("data/archive-encrypted-1514.txt") << 9
             << 3 << QStringLiteral("testarchive/dir1/file1.txt") << false << true << (qulonglong) 32 << QStringLiteral("2015-05-17T19:41:48");
 
     // p7zip version 15.09 tests
 
     QTest::newRow("normal-file-1509")
             << QFINDTESTDATA("data/archive-with-symlink-1509.txt") << 10
             << 4 << QStringLiteral("testarchive/dir2/file2.txt") << false << false << (qulonglong) 32 << QStringLiteral("2015-05-17T19:41:48");
 
     QTest::newRow("encrypted-1509")
             << QFINDTESTDATA("data/archive-encrypted-1509.txt") << 9
             << 3 << QStringLiteral("testarchive/dir1/file1.txt") << false << true << (qulonglong) 32 << QStringLiteral("2015-05-17T19:41:48");
 
     // p7zip version 9.38.1 tests
 
     QTest::newRow("normal-file-9381")
             << QFINDTESTDATA("data/archive-with-symlink-9381.txt") << 10
             << 4 << QStringLiteral("testarchive/dir2/file2.txt") << false << false << (qulonglong) 32 << QStringLiteral("2015-05-17T19:41:48");
 
     QTest::newRow("encrypted-9381")
             << QFINDTESTDATA("data/archive-encrypted-9381.txt") << 9
             << 3 << QStringLiteral("testarchive/dir1/file1.txt") << false << true << (qulonglong) 32 << QStringLiteral("2015-05-17T19:41:48");
 }
 
 void Cli7zTest::testList()
 {
     CliPlugin *plugin = new CliPlugin(this, {QStringLiteral("dummy.7z")});
-    QSignalSpy signalSpy(plugin, SIGNAL(entry(ArchiveEntry)));
+
+    int signalCount = 0;
+    QFETCH(int, someEntryIndex);
+    const Archive::Entry *someEntry;
+    QObject::connect(plugin, &CliPlugin::entry,
+                     [&](Archive::Entry *value)
+                     {
+                         if (signalCount == someEntryIndex) {
+                             someEntry = value;
+                         }
+                         signalCount++;
+                     });
 
     QFETCH(QString, outputTextFile);
     QFETCH(int, expectedEntriesCount);
 
     QFile outputText(outputTextFile);
     QVERIFY(outputText.open(QIODevice::ReadOnly));
 
     QTextStream outputStream(&outputText);
     while (!outputStream.atEnd()) {
         const QString line(outputStream.readLine());
         QVERIFY(plugin->readListLine(line));
     }
 
-    QCOMPARE(signalSpy.count(), expectedEntriesCount);
+    QCOMPARE(signalCount, expectedEntriesCount);
 
-    QFETCH(int, someEntryIndex);
-    QVERIFY(someEntryIndex < signalSpy.count());
-    Archive::Entry *entry = signalSpy.at(someEntryIndex).at(0).value<Archive::Entry *>();
+    QVERIFY(someEntryIndex < signalCount);
 
     QFETCH(QString, expectedName);
-    QCOMPARE(entry->property("fullPath").toString(), expectedName);
+    QCOMPARE(someEntry->property("fullPath").toString(), expectedName);
 
     QFETCH(bool, isDirectory);
-    QCOMPARE(entry->isDir(), isDirectory);
+    QCOMPARE(someEntry->isDir(), isDirectory);
 
     QFETCH(bool, isPasswordProtected);
-    QCOMPARE(entry->property("isPasswordProtected").toBool(), isPasswordProtected);
+    QCOMPARE(someEntry->property("isPasswordProtected").toBool(), isPasswordProtected);
 
     QFETCH(qulonglong, expectedSize);
-    QCOMPARE(entry->property("size").toULongLong(), expectedSize);
+    QCOMPARE(someEntry->property("size").toULongLong(), expectedSize);
 
     QFETCH(QString, expectedTimestamp);
-    QCOMPARE(entry->property("timestamp").toString(), expectedTimestamp);
+    QCOMPARE(someEntry->property("timestamp").toString(), expectedTimestamp);
 
     plugin->deleteLater();
 }
 
 void Cli7zTest::testListArgs_data()
 {
     QTest::addColumn<QString>("archiveName");
     QTest::addColumn<QString>("password");
     QTest::addColumn<QStringList>("expectedArgs");
 
     QTest::newRow("unencrypted")
             << QStringLiteral("/tmp/foo.7z")
             << QString()
             << QStringList {
                    QStringLiteral("l"),
                    QStringLiteral("-slt"),
                    QStringLiteral("/tmp/foo.7z")
                };
 
     QTest::newRow("header-encrypted")
             << QStringLiteral("/tmp/foo.7z")
             << QStringLiteral("1234")
             << QStringList {
                    QStringLiteral("l"),
                    QStringLiteral("-slt"),
                    QStringLiteral("-p1234"),
                    QStringLiteral("/tmp/foo.7z")
                };
 }
 
 void Cli7zTest::testListArgs()
 {
     QFETCH(QString, archiveName);
     CliPlugin *plugin = new CliPlugin(this, {QVariant(archiveName)});
     QVERIFY(plugin);
 
     const QStringList listArgs = { QStringLiteral("l"),
                                    QStringLiteral("-slt"),
                                    QStringLiteral("$PasswordSwitch"),
                                    QStringLiteral("$Archive") };
 
     QFETCH(QString, password);
     const auto replacedArgs = plugin->substituteListVariables(listArgs, password);
 
     QFETCH(QStringList, expectedArgs);
     QCOMPARE(replacedArgs, expectedArgs);
 
     plugin->deleteLater();
 }
 
 void Cli7zTest::testAddArgs_data()
 {
     QTest::addColumn<QString>("archiveName");
     QTest::addColumn<QString>("password");
     QTest::addColumn<bool>("encryptHeader");
     QTest::addColumn<int>("compressionLevel");
     QTest::addColumn<QStringList>("expectedArgs");
 
     QTest::newRow("unencrypted")
             << QStringLiteral("/tmp/foo.7z")
             << QString() << false << 5
             << QStringList {
                    QStringLiteral("a"),
                    QStringLiteral("/tmp/foo.7z"),
                    QStringLiteral("-mx=5")
                };
 
     QTest::newRow("encrypted")
             << QStringLiteral("/tmp/foo.7z")
             << QStringLiteral("1234") << false << 5
             << QStringList {
                    QStringLiteral("a"),
                    QStringLiteral("/tmp/foo.7z"),
                    QStringLiteral("-p1234"),
                    QStringLiteral("-mx=5")
                };
 
     QTest::newRow("header-encrypted")
             << QStringLiteral("/tmp/foo.7z")
             << QStringLiteral("1234") << true << 5
             << QStringList {
                    QStringLiteral("a"),
                    QStringLiteral("/tmp/foo.7z"),
                    QStringLiteral("-p1234"),
                    QStringLiteral("-mhe=on"),
                    QStringLiteral("-mx=5")
                };
 }
 
 void Cli7zTest::testAddArgs()
 {
     QFETCH(QString, archiveName);
     CliPlugin *plugin = new CliPlugin(this, {QVariant(archiveName)});
     QVERIFY(plugin);
 
     const QStringList addArgs = { QStringLiteral("a"),
                                   QStringLiteral("$Archive"),
                                   QStringLiteral("$PasswordSwitch"),
                                   QStringLiteral("$CompressionLevelSwitch"),
                                   QStringLiteral("$Files") };
 
     QFETCH(QString, password);
     QFETCH(bool, encryptHeader);
     QFETCH(int, compressionLevel);
 
     QStringList replacedArgs = plugin->substituteAddVariables(addArgs, {}, password, encryptHeader, compressionLevel);
 
     QFETCH(QStringList, expectedArgs);
     QCOMPARE(replacedArgs, expectedArgs);
 
     plugin->deleteLater();
 }
 
 void Cli7zTest::testExtractArgs_data()
 {
     QTest::addColumn<QString>("archiveName");
     QTest::addColumn<QList<Archive::Entry*>>("files");
     QTest::addColumn<bool>("preservePaths");
     QTest::addColumn<QString>("password");
     QTest::addColumn<QStringList>("expectedArgs");
 
     QTest::newRow("preserve paths, encrypted")
             << QStringLiteral("/tmp/foo.7z")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("aDir/b.txt"), QStringLiteral("aDir")),
                    new Archive::Entry(this, QStringLiteral("c.txt"), QString())
                }
             << true << QStringLiteral("1234")
             << QStringList {
                    QStringLiteral("x"),
                    QStringLiteral("-p1234"),
                    QStringLiteral("/tmp/foo.7z"),
                    QStringLiteral("aDir/b.txt"),
                    QStringLiteral("c.txt"),
                };
 
     QTest::newRow("preserve paths, unencrypted")
             << QStringLiteral("/tmp/foo.7z")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("aDir/b.txt"), QStringLiteral("aDir")),
                    new Archive::Entry(this, QStringLiteral("c.txt"), QString())
                }
             << true << QString()
             << QStringList {
                    QStringLiteral("x"),
                    QStringLiteral("/tmp/foo.7z"),
                    QStringLiteral("aDir/b.txt"),
                    QStringLiteral("c.txt"),
                };
 
     QTest::newRow("without paths, encrypted")
             << QStringLiteral("/tmp/foo.7z")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("aDir/b.txt"), QStringLiteral("aDir")),
                    new Archive::Entry(this, QStringLiteral("c.txt"), QString())
                }
             << false << QStringLiteral("1234")
             << QStringList {
                    QStringLiteral("e"),
                    QStringLiteral("-p1234"),
                    QStringLiteral("/tmp/foo.7z"),
                    QStringLiteral("aDir/b.txt"),
                    QStringLiteral("c.txt"),
                };
 
     QTest::newRow("without paths, unencrypted")
             << QStringLiteral("/tmp/foo.7z")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("aDir/b.txt"), QStringLiteral("aDir")),
                    new Archive::Entry(this, QStringLiteral("c.txt"), QString())
                }
             << false << QString()
             << QStringList {
                    QStringLiteral("e"),
                    QStringLiteral("/tmp/foo.7z"),
                    QStringLiteral("aDir/b.txt"),
                    QStringLiteral("c.txt"),
                };
 }
 
 void Cli7zTest::testExtractArgs()
 {
     QFETCH(QString, archiveName);
     CliPlugin *plugin = new CliPlugin(this, {QVariant(archiveName)});
     QVERIFY(plugin);
 
     const QStringList extractArgs = { QStringLiteral("$PreservePathSwitch"),
                                       QStringLiteral("$PasswordSwitch"),
                                       QStringLiteral("$Archive"),
                                       QStringLiteral("$Files") };
 
     QFETCH(QList<Archive::Entry*>, files);
     QFETCH(bool, preservePaths);
     QFETCH(QString, password);
 
     QStringList replacedArgs = plugin->substituteCopyVariables(extractArgs, files, preservePaths, password);
     QVERIFY(replacedArgs.size() >= extractArgs.size());
 
     QFETCH(QStringList, expectedArgs);
     QCOMPARE(replacedArgs, expectedArgs);
 
     plugin->deleteLater();
 }
diff --git a/autotests/plugins/clirarplugin/clirartest.cpp b/autotests/plugins/clirarplugin/clirartest.cpp
index c97b491a..d752ee20 100644
--- a/autotests/plugins/clirarplugin/clirartest.cpp
+++ b/autotests/plugins/clirarplugin/clirartest.cpp
@@ -1,424 +1,433 @@
 /*
  * Copyright (c) 2011,2014 Raphael Kubo da Costa <rakuco@FreeBSD.org>
  * Copyright (c) 2015,2016 Ragnar Thomsen <rthomsen6@gmail.com>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ( INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION ) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * ( INCLUDING NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "clirartest.h"
 #include "kerfuffle/archiveentry.h"
 
 #include <QFile>
 #include <QSignalSpy>
 #include <QTest>
 #include <QTextStream>
 
 #include <KPluginLoader>
 
 QTEST_GUILESS_MAIN(CliRarTest)
 
 using namespace Kerfuffle;
 
 void CliRarTest::initTestCase()
 {
     m_plugin = new Plugin(this);
     foreach (Plugin *plugin, m_pluginManger.availablePlugins()) {
         if (plugin->metaData().pluginId() == QStringLiteral("kerfuffle_clirar")) {
             m_plugin = plugin;
             return;
         }
     }
 }
 
 void CliRarTest::testArchive_data()
 {
     QTest::addColumn<QString>("archivePath");
     QTest::addColumn<QString>("expectedFileName");
     QTest::addColumn<bool>("isReadOnly");
     QTest::addColumn<bool>("isSingleFolder");
     QTest::addColumn<Archive::EncryptionType>("expectedEncryptionType");
     QTest::addColumn<QString>("expectedSubfolderName");
 
     QString archivePath = QFINDTESTDATA("data/one_toplevel_folder.rar");
     QTest::newRow("archive with one top-level folder")
             << archivePath
             << QFileInfo(archivePath).fileName()
             << false << true << Archive::Unencrypted
             << QStringLiteral("A");
 }
 
 void CliRarTest::testArchive()
 {
     if (!m_plugin->isValid()) {
         QSKIP("clirar plugin not available. Skipping test.", SkipSingle);
     }
 
     QFETCH(QString, archivePath);
     Archive *archive = Archive::create(archivePath, m_plugin, this);
     QVERIFY(archive);
 
     if (!archive->isValid()) {
         QSKIP("Could not load the clirar plugin. Skipping test.", SkipSingle);
     }
 
     QFETCH(QString, expectedFileName);
     QCOMPARE(QFileInfo(archive->fileName()).fileName(), expectedFileName);
 
     QFETCH(bool, isReadOnly);
     QCOMPARE(archive->isReadOnly(), isReadOnly);
 
     QFETCH(bool, isSingleFolder);
     QCOMPARE(archive->isSingleFolderArchive(), isSingleFolder);
 
     QFETCH(Archive::EncryptionType, expectedEncryptionType);
     QCOMPARE(archive->encryptionType(), expectedEncryptionType);
 
     QFETCH(QString, expectedSubfolderName);
     QCOMPARE(archive->subfolderName(), expectedSubfolderName);
 }
 
 void CliRarTest::testList_data()
 {
     QTest::addColumn<QString>("outputTextFile");
     QTest::addColumn<int>("expectedEntriesCount");
     // Index of some entry to be tested.
     QTest::addColumn<int>("someEntryIndex");
     // Entry metadata.
     QTest::addColumn<QString>("expectedName");
     QTest::addColumn<bool>("isDirectory");
     QTest::addColumn<bool>("isPasswordProtected");
     QTest::addColumn<QString>("symlinkTarget");
     QTest::addColumn<qulonglong>("expectedSize");
     QTest::addColumn<qulonglong>("expectedCompressedSize");
     QTest::addColumn<QString>("expectedTimestamp");
 
     // Unrar 5 tests
 
     QTest::newRow("normal-file-unrar5")
             << QFINDTESTDATA("data/archive-with-symlink-unrar5.txt") << 8
             << 2 << QStringLiteral("rartest/file2.txt") << false << false << QString() << (qulonglong) 14 << (qulonglong) 23 << QStringLiteral("2016-03-21T08:57:36");
 
     QTest::newRow("symlink-unrar5")
             << QFINDTESTDATA("data/archive-with-symlink-unrar5.txt") << 8
             << 3 << QStringLiteral("rartest/linktofile1.txt") << false << false << QStringLiteral("file1.txt") << (qulonglong) 9 << (qulonglong) 9 << QStringLiteral("2016-03-21T08:58:16");
 
     QTest::newRow("encrypted-unrar5")
             << QFINDTESTDATA("data/archive-encrypted-unrar5.txt") << 7
             << 2 << QStringLiteral("rartest/file2.txt") << false << true << QString() << (qulonglong) 14 << (qulonglong) 32 << QStringLiteral("2016-03-21T17:03:36");
 
     QTest::newRow("recovery-record-unrar5")
             << QFINDTESTDATA("data/archive-recovery-record-unrar5.txt") << 3
             << 0 << QStringLiteral("file1.txt") << false << false << QString() << (qulonglong) 32 << (qulonglong) 33 << QStringLiteral("2015-07-26T19:04:38");
 
     QTest::newRow("corrupt-archive-unrar5")
             << QFINDTESTDATA("data/archive-corrupt-file-header-unrar5.txt") << 8
             << 6 << QStringLiteral("dir1/") << true << false << QString() << (qulonglong) 0 << (qulonglong) 0 << QStringLiteral("2015-05-14T01:45:24");
 
     // Unrar 4 tests
 
     QTest::newRow("normal-file-unrar4")
             << QFINDTESTDATA("data/archive-with-symlink-unrar4.txt") << 8
             << 2 << QStringLiteral("rartest/file2.txt") << false << false << QString() << (qulonglong) 14 << (qulonglong) 23 << QStringLiteral("2016-03-21T08:57:00");
 
     QTest::newRow("symlink-unrar4")
             << QFINDTESTDATA("data/archive-with-symlink-unrar4.txt") << 8
             << 3 << QStringLiteral("rartest/linktofile1.txt") << false << false << QStringLiteral("file1.txt") << (qulonglong) 9 << (qulonglong) 9 << QStringLiteral("2016-03-21T08:58:00");
 
     QTest::newRow("encrypted-unrar4")
             << QFINDTESTDATA("data/archive-encrypted-unrar4.txt") << 7
             << 2 << QStringLiteral("rartest/file2.txt") << false << true << QString() << (qulonglong) 14 << (qulonglong) 32 << QStringLiteral("2016-03-21T17:03:00");
 
     QTest::newRow("recovery-record-unrar4")
             << QFINDTESTDATA("data/archive-recovery-record-unrar4.txt") << 3
             << 0 << QStringLiteral("file1.txt") << false << false << QString() << (qulonglong) 32 << (qulonglong) 33 << QStringLiteral("2015-07-26T19:04:00");
 
     QTest::newRow("corrupt-archive-unrar4")
             << QFINDTESTDATA("data/archive-corrupt-file-header-unrar4.txt") << 8
             << 6 << QStringLiteral("dir1/") << true << false << QString() << (qulonglong) 0 << (qulonglong) 0 << QStringLiteral("2015-05-14T01:45:00");
 
     /*
      * Check that the plugin will not crash when reading corrupted archives, which
      * have lines such as "Unexpected end of archive" or "??? - the file header is
      * corrupt" instead of a file name and the header string after it.
      *
      * See bug 262857 and commit 2042997013432cdc6974f5b26d39893a21e21011.
      */
     QTest::newRow("corrupt-archive-unrar3")
             << QFINDTESTDATA("data/archive-corrupt-file-header-unrar3.txt") << 1
             << 0 << QStringLiteral("some-file.ext") << false << false << QString() << (qulonglong) 732522496 << (qulonglong) 14851208 << QStringLiteral("2010-10-29T20:47:00");
 }
 
 void CliRarTest::testList()
 {
     CliPlugin *rarPlugin = new CliPlugin(this, {QStringLiteral("dummy.rar")});
-    QSignalSpy signalSpy(rarPlugin, SIGNAL(entry(ArchiveEntry)));
+
+    int signalCount = 0;
+    QFETCH(int, someEntryIndex);
+    const Archive::Entry *someEntry;
+    QObject::connect(rarPlugin, &CliPlugin::entry,
+                     [&](Archive::Entry *value)
+                     {
+                         if (signalCount == someEntryIndex) {
+                             someEntry = value;
+                         }
+                         signalCount++;
+                     });
 
     QFETCH(QString, outputTextFile);
     QFETCH(int, expectedEntriesCount);
 
     QFile outputText(outputTextFile);
     QVERIFY(outputText.open(QIODevice::ReadOnly));
 
     QTextStream outputStream(&outputText);
     while (!outputStream.atEnd()) {
         const QString line(outputStream.readLine());
         QVERIFY(rarPlugin->readListLine(line));
     }
 
-    QCOMPARE(signalSpy.count(), expectedEntriesCount);
+    QCOMPARE(signalCount, expectedEntriesCount);
 
-    QFETCH(int, someEntryIndex);
-    QVERIFY(someEntryIndex < signalSpy.count());
-    Archive::Entry *entry = signalSpy.at(someEntryIndex).at(0).value<Archive::Entry *>();
+    QVERIFY(someEntryIndex < signalCount);
 
     QFETCH(QString, expectedName);
-    QCOMPARE(entry->property("fullPath").toString(), expectedName);
+    QCOMPARE(someEntry->property("fullPath").toString(), expectedName);
 
     QFETCH(bool, isDirectory);
-    QCOMPARE(entry->isDir(), isDirectory);
+    QCOMPARE(someEntry->isDir(), isDirectory);
 
     QFETCH(bool, isPasswordProtected);
-    QCOMPARE(entry->property("isPasswordProtected").toBool(), isPasswordProtected);
+    QCOMPARE(someEntry->property("isPasswordProtected").toBool(), isPasswordProtected);
 
     QFETCH(QString, symlinkTarget);
-    QCOMPARE(entry->property("link").toString(), symlinkTarget);
+    QCOMPARE(someEntry->property("link").toString(), symlinkTarget);
 
     QFETCH(qulonglong, expectedSize);
-    QCOMPARE(entry->property("size").toULongLong(), expectedSize);
+    QCOMPARE(someEntry->property("size").toULongLong(), expectedSize);
 
     QFETCH(qulonglong, expectedCompressedSize);
-    QCOMPARE(entry->property("compressedSize").toULongLong(), expectedCompressedSize);
+    QCOMPARE(someEntry->property("compressedSize").toULongLong(), expectedCompressedSize);
 
     QFETCH(QString, expectedTimestamp);
-    QCOMPARE(entry->property("timestamp").toString(), expectedTimestamp);
+    QCOMPARE(someEntry->property("timestamp").toString(), expectedTimestamp);
 
     rarPlugin->deleteLater();
 }
 
 void CliRarTest::testListArgs_data()
 {
     QTest::addColumn<QString>("archiveName");
     QTest::addColumn<QString>("password");
     QTest::addColumn<QStringList>("expectedArgs");
 
     QTest::newRow("unencrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QString()
             << QStringList {
                    QStringLiteral("vt"),
                    QStringLiteral("-v"),
                    QStringLiteral("/tmp/foo.rar")
                };
 
     QTest::newRow("header-encrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QStringLiteral("1234")
             << QStringList {
                    QStringLiteral("vt"),
                    QStringLiteral("-v"),
                    QStringLiteral("-p1234"),
                    QStringLiteral("/tmp/foo.rar")
                };
 }
 
 void CliRarTest::testListArgs()
 {
     QFETCH(QString, archiveName);
     CliPlugin *plugin = new CliPlugin(this, {QVariant(archiveName)});
     QVERIFY(plugin);
 
     const QStringList listArgs = { QStringLiteral("vt"),
                                    QStringLiteral("-v"),
                                    QStringLiteral("$PasswordSwitch"),
                                    QStringLiteral("$Archive") };
 
     QFETCH(QString, password);
     const auto replacedArgs = plugin->substituteListVariables(listArgs, password);
 
     QFETCH(QStringList, expectedArgs);
     QCOMPARE(replacedArgs, expectedArgs);
 
     plugin->deleteLater();
 }
 
 void CliRarTest::testAddArgs_data()
 {
     QTest::addColumn<QString>("archiveName");
     QTest::addColumn<QString>("password");
     QTest::addColumn<bool>("encryptHeader");
     QTest::addColumn<int>("compressionLevel");
     QTest::addColumn<QStringList>("expectedArgs");
 
     QTest::newRow("unencrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QString() << false << 3
             << QStringList {
                    QStringLiteral("a"),
                    QStringLiteral("/tmp/foo.rar"),
                    QStringLiteral("-m3")
                };
 
     QTest::newRow("encrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QStringLiteral("1234") << false << 3
             << QStringList {
                    QStringLiteral("a"),
                    QStringLiteral("/tmp/foo.rar"),
                    QStringLiteral("-p1234"),
                    QStringLiteral("-m3")
                };
 
     QTest::newRow("header-encrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QStringLiteral("1234") << true << 3
             << QStringList {
                    QStringLiteral("a"),
                    QStringLiteral("/tmp/foo.rar"),
                    QStringLiteral("-hp1234"),
                    QStringLiteral("-m3")
                };
 }
 
 void CliRarTest::testAddArgs()
 {
     QFETCH(QString, archiveName);
     CliPlugin *rarPlugin = new CliPlugin(this, {QVariant(archiveName)});
     QVERIFY(rarPlugin);
 
     const QStringList addArgs = { QStringLiteral("a"),
                                   QStringLiteral("$Archive"),
                                   QStringLiteral("$PasswordSwitch"),
                                   QStringLiteral("$CompressionLevelSwitch"),
                                   QStringLiteral("$Files") };
 
     QFETCH(QString, password);
     QFETCH(bool, encryptHeader);
     QFETCH(int, compressionLevel);
 
     QStringList replacedArgs = rarPlugin->substituteAddVariables(addArgs, {}, password, encryptHeader, compressionLevel);
 
     QFETCH(QStringList, expectedArgs);
     QCOMPARE(replacedArgs, expectedArgs);
 
     rarPlugin->deleteLater();
 }
 
 void CliRarTest::testExtractArgs_data()
 {
     QTest::addColumn<QString>("archiveName");
     QTest::addColumn<QList<Archive::Entry*>>("files");
     QTest::addColumn<bool>("preservePaths");
     QTest::addColumn<QString>("password");
     QTest::addColumn<QStringList>("expectedArgs");
 
     QTest::newRow("preserve paths, encrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("aDir/b.txt"), QStringLiteral("aDir")),
                    new Archive::Entry(this, QStringLiteral("c.txt"), QString())
                }
             << true << QStringLiteral("1234")
             << QStringList {
                    QStringLiteral("-kb"),
                    QStringLiteral("-p-"),
                    QStringLiteral("x"),
                    QStringLiteral("-p1234"),
                    QStringLiteral("/tmp/foo.rar"),
                    QStringLiteral("aDir/b.txt"),
                    QStringLiteral("c.txt"),
                };
 
     QTest::newRow("preserve paths, unencrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("aDir/b.txt"), QStringLiteral("aDir")),
                    new Archive::Entry(this, QStringLiteral("c.txt"), QString())
                }
             << true << QString()
             << QStringList {
                    QStringLiteral("-kb"),
                    QStringLiteral("-p-"),
                    QStringLiteral("x"),
                    QStringLiteral("/tmp/foo.rar"),
                    QStringLiteral("aDir/b.txt"),
                    QStringLiteral("c.txt"),
                };
 
     QTest::newRow("without paths, encrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("aDir/b.txt"), QStringLiteral("aDir")),
                    new Archive::Entry(this, QStringLiteral("c.txt"), QString())
                }
             << false << QStringLiteral("1234")
             << QStringList {
                    QStringLiteral("-kb"),
                    QStringLiteral("-p-"),
                    QStringLiteral("e"),
                    QStringLiteral("-p1234"),
                    QStringLiteral("/tmp/foo.rar"),
                    QStringLiteral("aDir/b.txt"),
                    QStringLiteral("c.txt"),
                };
 
     QTest::newRow("without paths, unencrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("aDir/b.txt"), QStringLiteral("aDir")),
                    new Archive::Entry(this, QStringLiteral("c.txt"), QString())
                }
             << false << QString()
             << QStringList {
                    QStringLiteral("-kb"),
                    QStringLiteral("-p-"),
                    QStringLiteral("e"),
                    QStringLiteral("/tmp/foo.rar"),
                    QStringLiteral("aDir/b.txt"),
                    QStringLiteral("c.txt"),
                };
 }
 
 void CliRarTest::testExtractArgs()
 {
     QFETCH(QString, archiveName);
     CliPlugin *rarPlugin = new CliPlugin(this, {QVariant(archiveName)});
     QVERIFY(rarPlugin);
 
     const QStringList extractArgs = { QStringLiteral("-kb"),
                                       QStringLiteral("-p-"),
                                       QStringLiteral("$PreservePathSwitch"),
                                       QStringLiteral("$PasswordSwitch"),
                                       QStringLiteral("$Archive"),
                                       QStringLiteral("$Files") };
 
     QFETCH(QList<Archive::Entry*>, files);
     QFETCH(bool, preservePaths);
     QFETCH(QString, password);
 
     QStringList replacedArgs = rarPlugin->substituteCopyVariables(extractArgs, files, preservePaths, password);
     QVERIFY(replacedArgs.size() >= extractArgs.size());
 
     QFETCH(QStringList, expectedArgs);
     QCOMPARE(replacedArgs, expectedArgs);
 
     rarPlugin->deleteLater();
 }
diff --git a/autotests/plugins/cliunarchiverplugin/cliunarchivertest.cpp b/autotests/plugins/cliunarchiverplugin/cliunarchivertest.cpp
index 7a472ed4..bf74d53d 100644
--- a/autotests/plugins/cliunarchiverplugin/cliunarchivertest.cpp
+++ b/autotests/plugins/cliunarchiverplugin/cliunarchivertest.cpp
@@ -1,383 +1,392 @@
 /*
  * Copyright (C) 2016 Elvis Angelaccio <elvis.angelaccio@kdemail.net>
  *
  * 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; either version 2
  * of the License, or (at your option) any later version.
  *
  * 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, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  *
  */
 
 #include "cliunarchivertest.h"
 #include "jobs.h"
 #include "kerfuffle/archiveentry.h"
 
 #include <QDirIterator>
 #include <QFile>
 #include <QSignalSpy>
 #include <QTest>
 #include <QTextStream>
 
 #include <KPluginLoader>
 
 QTEST_GUILESS_MAIN(CliUnarchiverTest)
 
 using namespace Kerfuffle;
 
 void CliUnarchiverTest::initTestCase()
 {
     m_plugin = new Plugin(this);
     foreach (Plugin *plugin, m_pluginManger.availablePlugins()) {
         if (plugin->metaData().pluginId() == QStringLiteral("kerfuffle_cliunarchiver")) {
             m_plugin = plugin;
             return;
         }
     }
 }
 
 void CliUnarchiverTest::testArchive_data()
 {
     QTest::addColumn<QString>("archivePath");
     QTest::addColumn<QString>("expectedFileName");
     QTest::addColumn<bool>("isReadOnly");
     QTest::addColumn<bool>("isSingleFolder");
     QTest::addColumn<Archive::EncryptionType>("expectedEncryptionType");
     QTest::addColumn<QString>("expectedSubfolderName");
 
 
     QString archivePath = QFINDTESTDATA("data/one_toplevel_folder.rar");
     QTest::newRow("archive with one top-level folder")
             << archivePath
             << QFileInfo(archivePath).fileName()
             << true << true << Archive::Unencrypted
             << QStringLiteral("A");
 
     archivePath = QFINDTESTDATA("data/multiple_toplevel_entries.rar");
     QTest::newRow("archive with multiple top-level entries")
             << archivePath
             << QFileInfo(archivePath).fileName()
             << true << false << Archive::Unencrypted
             << QStringLiteral("multiple_toplevel_entries");
 
     archivePath = QFINDTESTDATA("data/encrypted_entries.rar");
     QTest::newRow("archive with encrypted entries")
             << archivePath
             << QFileInfo(archivePath).fileName()
             << true << true << Archive::Encrypted
             << QStringLiteral("A");
 }
 
 void CliUnarchiverTest::testArchive()
 {
     if (!m_plugin->isValid()) {
         QSKIP("cliunarchiver plugin not available. Skipping test.", SkipSingle);
     }
 
     QFETCH(QString, archivePath);
     Archive *archive = Archive::create(archivePath, m_plugin, this);
     QVERIFY(archive);
 
     if (!archive->isValid()) {
         QSKIP("Could not load the cliunarchiver plugin. Skipping test.", SkipSingle);
     }
 
     QFETCH(QString, expectedFileName);
     QCOMPARE(QFileInfo(archive->fileName()).fileName(), expectedFileName);
 
     QFETCH(bool, isReadOnly);
     QCOMPARE(archive->isReadOnly(), isReadOnly);
 
     QFETCH(bool, isSingleFolder);
     QCOMPARE(archive->isSingleFolderArchive(), isSingleFolder);
 
     QFETCH(Archive::EncryptionType, expectedEncryptionType);
     QCOMPARE(archive->encryptionType(), expectedEncryptionType);
 
     QFETCH(QString, expectedSubfolderName);
     QCOMPARE(archive->subfolderName(), expectedSubfolderName);
 }
 
 void CliUnarchiverTest::testList_data()
 {
     QTest::addColumn<QString>("jsonFilePath");
     QTest::addColumn<int>("expectedEntriesCount");
     // Index of some entry to be tested.
     QTest::addColumn<int>("someEntryIndex");
     // Entry metadata.
     QTest::addColumn<QString>("expectedName");
     QTest::addColumn<bool>("isDirectory");
     QTest::addColumn<bool>("isPasswordProtected");
     QTest::addColumn<qulonglong>("expectedSize");
     QTest::addColumn<qulonglong>("expectedCompressedSize");
     QTest::addColumn<QString>("expectedTimestamp");
 
     QTest::newRow("archive with one top-level folder")
             << QFINDTESTDATA("data/one_toplevel_folder.json") << 9
             << 6 << QStringLiteral("A/B/C/") << true << false << (qulonglong) 0 << (qulonglong) 0 << QStringLiteral("2015-12-21 16:57:20 +0100");
     QTest::newRow("archive with multiple top-level entries")
             << QFINDTESTDATA("data/multiple_toplevel_entries.json") << 12
             << 4 << QStringLiteral("data/A/B/test1.txt") << false << false << (qulonglong) 7 << (qulonglong) 7 << QStringLiteral("2015-12-21 16:56:28 +0100");
     QTest::newRow("archive with encrypted entries")
             << QFINDTESTDATA("data/encrypted_entries.json") << 9
             << 5 << QStringLiteral("A/test1.txt") << false << true << (qulonglong) 7 << (qulonglong) 32 << QStringLiteral("2015-12-21 16:56:28 +0100");
     QTest::newRow("huge archive")
             << QFINDTESTDATA("data/huge_archive.json") << 250
             << 8 << QStringLiteral("PsycOPacK/Base Dictionnaries/att800") << false << false << (qulonglong) 593687 << (qulonglong) 225219 << QStringLiteral("2011-08-14 03:10:10 +0200");
 }
 
 void CliUnarchiverTest::testList()
 {
     CliPlugin *unarPlugin = new CliPlugin(this, {QStringLiteral("dummy.rar")});
-    QSignalSpy signalSpy(unarPlugin, SIGNAL(entry(ArchiveEntry)));
+
+    int signalCount = 0;
+    QFETCH(int, someEntryIndex);
+    const Archive::Entry *someEntry;
+    QObject::connect(unarPlugin, &CliPlugin::entry,
+                     [&](Archive::Entry *value)
+                     {
+                         if (signalCount == someEntryIndex) {
+                             someEntry = value;
+                         }
+                         signalCount++;
+                     });
 
     QFETCH(QString, jsonFilePath);
     QFETCH(int, expectedEntriesCount);
 
     QFile jsonFile(jsonFilePath);
     QVERIFY(jsonFile.open(QIODevice::ReadOnly));
 
     QTextStream stream(&jsonFile);
     unarPlugin->setJsonOutput(stream.readAll());
 
-    QCOMPARE(signalSpy.count(), expectedEntriesCount);
+    QCOMPARE(signalCount, expectedEntriesCount);
 
-    QFETCH(int, someEntryIndex);
-    QVERIFY(someEntryIndex < signalSpy.count());
-    Archive::Entry *entry = signalSpy.at(someEntryIndex).at(0).value<Archive::Entry *>();
+    QVERIFY(someEntryIndex < signalCount);
 
     QFETCH(QString, expectedName);
-    QCOMPARE(entry->property("fullPath").toString(), expectedName);
+    QCOMPARE(someEntry->property("fullPath").toString(), expectedName);
 
     QFETCH(bool, isDirectory);
-    QCOMPARE(entry->isDir(), isDirectory);
+    QCOMPARE(someEntry->isDir(), isDirectory);
 
     QFETCH(bool, isPasswordProtected);
-    QCOMPARE(entry->property("isPasswordProtected").toBool(), isPasswordProtected);
+    QCOMPARE(someEntry->property("isPasswordProtected").toBool(), isPasswordProtected);
 
     QFETCH(qulonglong, expectedSize);
-    QCOMPARE(entry->property("size").toULongLong(), expectedSize);
+    QCOMPARE(someEntry->property("size").toULongLong(), expectedSize);
 
     QFETCH(qulonglong, expectedCompressedSize);
-    QCOMPARE(entry->property("compressedSize").toULongLong(), expectedCompressedSize);
+    QCOMPARE(someEntry->property("compressedSize").toULongLong(), expectedCompressedSize);
 
     QFETCH(QString, expectedTimestamp);
-    QCOMPARE(entry->property("timestamp").toString(), expectedTimestamp);
+    QCOMPARE(someEntry->property("timestamp").toString(), expectedTimestamp);
 
     unarPlugin->deleteLater();
 }
 
 void CliUnarchiverTest::testListArgs_data()
 {
     QTest::addColumn<QString>("archiveName");
     QTest::addColumn<QString>("password");
     QTest::addColumn<QStringList>("expectedArgs");
 
     QTest::newRow("unencrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QString()
             << QStringList {
                    QStringLiteral("-json"),
                    QStringLiteral("/tmp/foo.rar")
                };
 
     QTest::newRow("header-encrypted")
             << QStringLiteral("/tmp/foo.rar")
             << QStringLiteral("1234")
             << QStringList {
                    QStringLiteral("-json"),
                    QStringLiteral("/tmp/foo.rar"),
                    QStringLiteral("-password"),
                    QStringLiteral("1234")
                };
 }
 
 void CliUnarchiverTest::testListArgs()
 {
     QFETCH(QString, archiveName);
     CliPlugin *plugin = new CliPlugin(this, {QVariant(archiveName)});
     QVERIFY(plugin);
 
     const QStringList listArgs = { QStringLiteral("-json"),
                                    QStringLiteral("$Archive"),
                                    QStringLiteral("$PasswordSwitch") };
 
     QFETCH(QString, password);
     const auto replacedArgs = plugin->substituteListVariables(listArgs, password);
 
     QFETCH(QStringList, expectedArgs);
     QCOMPARE(replacedArgs, expectedArgs);
 
     plugin->deleteLater();
 }
 
 void CliUnarchiverTest::testExtraction_data()
 {
     QTest::addColumn<QString>("archivePath");
     QTest::addColumn<QList<Archive::Entry*>>("entriesToExtract");
     QTest::addColumn<ExtractionOptions>("extractionOptions");
     QTest::addColumn<int>("expectedExtractedEntriesCount");
 
     ExtractionOptions options;
     options[QStringLiteral("AlwaysUseTmpDir")] = true;
 
     ExtractionOptions optionsPreservePaths = options;
     optionsPreservePaths[QStringLiteral("PreservePaths")] = true;
 
     ExtractionOptions dragAndDropOptions = optionsPreservePaths;
     dragAndDropOptions[QStringLiteral("DragAndDrop")] = true;
 
     QTest::newRow("extract the whole multiple_toplevel_entries.rar")
             << QFINDTESTDATA("data/multiple_toplevel_entries.rar")
             << QList<Archive::Entry*>()
             << optionsPreservePaths
             << 12;
 
     QTest::newRow("extract selected entries from a rar, without paths")
             << QFINDTESTDATA("data/one_toplevel_folder.rar")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("A/test2.txt"), QStringLiteral("A")),
                    new Archive::Entry(this, QStringLiteral("A/B/test1.txt"), QStringLiteral("A/B"))
                }
             << options
             << 2;
 
     QTest::newRow("extract selected entries from a rar, preserve paths")
             << QFINDTESTDATA("data/one_toplevel_folder.rar")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("A/test2.txt"), QStringLiteral("A")),
                    new Archive::Entry(this, QStringLiteral("A/B/test1.txt"), QStringLiteral("A/B"))
                }
             << optionsPreservePaths
             << 4;
 
     QTest::newRow("extract selected entries from a rar, drag-and-drop")
             << QFINDTESTDATA("data/one_toplevel_folder.rar")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("A/B/C/"), QStringLiteral("A/B/")),
                    new Archive::Entry(this, QStringLiteral("A/test2.txt"), QStringLiteral("A/")),
                    new Archive::Entry(this, QStringLiteral("A/B/C/test1.txt"), QStringLiteral("A/B/")),
                    new Archive::Entry(this, QStringLiteral("A/B/C/test2.txt"), QStringLiteral("A/B/"))
                }
             << dragAndDropOptions
             << 4;
 
     QTest::newRow("rar with empty folders")
             << QFINDTESTDATA("data/empty_folders.rar")
             << QList<Archive::Entry*>()
             << optionsPreservePaths
             << 5;
 }
 
 // TODO: we can remove this test (which is duplicated from kerfuffle/archivetest)
 // if we ever ends up using a temp dir for any cliplugin, instead of only for cliunarchiver.
 void CliUnarchiverTest::testExtraction()
 {
     if (!m_plugin->isValid()) {
         QSKIP("cliunarchiver plugin not available. Skipping test.", SkipSingle);
     }
 
     QFETCH(QString, archivePath);
     Archive *archive = Archive::create(archivePath, m_plugin, this);
     QVERIFY(archive);
 
     if (!archive->isValid()) {
         QSKIP("Could not load the cliunarchiver plugin. Skipping test.", SkipSingle);
     }
 
     QTemporaryDir destDir;
     if (!destDir.isValid()) {
         QSKIP("Could not create a temporary directory for extraction. Skipping test.", SkipSingle);
     }
 
     QFETCH(QList<Archive::Entry*>, entriesToExtract);
     QFETCH(ExtractionOptions, extractionOptions);
     auto extractionJob = archive->copyFiles(entriesToExtract, destDir.path(), extractionOptions);
 
     QEventLoop eventLoop(this);
     connect(extractionJob, &KJob::result, &eventLoop, &QEventLoop::quit);
     extractionJob->start();
     eventLoop.exec(); // krazy:exclude=crashy
 
     QFETCH(int, expectedExtractedEntriesCount);
     int extractedEntriesCount = 0;
 
     QDirIterator dirIt(destDir.path(), QDir::AllEntries | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
     while (dirIt.hasNext()) {
         extractedEntriesCount++;
         dirIt.next();
     }
 
     QCOMPARE(extractedEntriesCount, expectedExtractedEntriesCount);
 
     archive->deleteLater();
 }
 
 void CliUnarchiverTest::testExtractArgs_data()
 {
     QTest::addColumn<QString>("archiveName");
     QTest::addColumn<QList<Archive::Entry*>>("files");
     QTest::addColumn<QString>("password");
     QTest::addColumn<QStringList>("expectedArgs");
 
     QTest::newRow("encrypted, multiple files")
             << QStringLiteral("/tmp/foo.rar")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("aDir/b.txt"), QStringLiteral("aDir")),
                    new Archive::Entry(this, QStringLiteral("c.txt"), QString())
                }
             << QStringLiteral("1234")
             << QStringList {
                    QStringLiteral("-D"),
                    QStringLiteral("/tmp/foo.rar"),
                    QStringLiteral("aDir/b.txt"),
                    QStringLiteral("c.txt"),
                    QStringLiteral("-password"),
                    QStringLiteral("1234")
                };
 
     QTest::newRow("unencrypted, multiple files")
             << QStringLiteral("/tmp/foo.rar")
             << QList<Archive::Entry*> {
                    new Archive::Entry(this, QStringLiteral("aDir/b.txt"), QStringLiteral("aDir")),
                    new Archive::Entry(this, QStringLiteral("c.txt"), QString())
                }
             << QString()
             << QStringList {
                    QStringLiteral("-D"),
                    QStringLiteral("/tmp/foo.rar"),
                    QStringLiteral("aDir/b.txt"),
                    QStringLiteral("c.txt"),
                };
 }
 
 void CliUnarchiverTest::testExtractArgs()
 {
     QFETCH(QString, archiveName);
     CliPlugin *plugin = new CliPlugin(this, {QVariant(archiveName)});
     QVERIFY(plugin);
 
     const QStringList extractArgs = { QStringLiteral("-D"),
                                       QStringLiteral("$Archive"),
                                       QStringLiteral("$Files"),
                                       QStringLiteral("$PasswordSwitch") };
 
     QFETCH(QList<Archive::Entry*>, files);
     QFETCH(QString, password);
 
     QStringList replacedArgs = plugin->substituteCopyVariables(extractArgs, files, false, password);
     QVERIFY(replacedArgs.size() >= extractArgs.size());
 
     QFETCH(QStringList, expectedArgs);
     QCOMPARE(replacedArgs, expectedArgs);
 
     plugin->deleteLater();
 }