diff --git a/src/fs/btrfs.cpp b/src/fs/btrfs.cpp
index 119895b..16890b7 100644
--- a/src/fs/btrfs.cpp
+++ b/src/fs/btrfs.cpp
@@ -106,7 +106,8 @@ qint64 btrfs::maxLabelLength() const
 
 qint64 btrfs::readUsedCapacity(const QString& deviceNode) const
 {
-    ExternalCommand cmd(QStringLiteral("btrfs"), QStringList() << QStringLiteral("filesystem") << QStringLiteral("show") << QStringLiteral("--raw") << deviceNode);
+    ExternalCommand cmd(QStringLiteral("btrfs"),
+                        { QStringLiteral("filesystem"), QStringLiteral("show"), QStringLiteral("--raw"), deviceNode });
 
     if (cmd.run()) {
         QRegExp rxBytesUsed(QStringLiteral(" used (\\d+) path ") + deviceNode);
@@ -120,13 +121,13 @@ qint64 btrfs::readUsedCapacity(const QString& deviceNode) const
 
 bool btrfs::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("btrfsck"), QStringList() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("btrfsck"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool btrfs::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.btrfs"), QStringList() << QStringLiteral("--force") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.btrfs"), { QStringLiteral("--force"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
@@ -140,17 +141,18 @@ bool btrfs::resize(Report& report, const QString& deviceNode, qint64 length) con
 
     bool rval = false;
 
-    ExternalCommand mountCmd(report, QStringLiteral("mount"), QStringList() << QStringLiteral("--verbose") << QStringLiteral("--types") << QStringLiteral("btrfs") << deviceNode << tempDir.path());
+    ExternalCommand mountCmd(report, QStringLiteral("mount"),
+                             { QStringLiteral("--verbose"),  QStringLiteral("--types"), QStringLiteral("btrfs"), deviceNode, tempDir.path() });
 
     if (mountCmd.run(-1) && mountCmd.exitCode() == 0) {
-        ExternalCommand resizeCmd(report, QStringLiteral("btrfs"), QStringList() << QStringLiteral("filesystem") << QStringLiteral("resize") << QString::number(length) << tempDir.path());
+        ExternalCommand resizeCmd(report, QStringLiteral("btrfs"), { QStringLiteral("filesystem"), QStringLiteral("resize"), QString::number(length), tempDir.path() });
 
         if (resizeCmd.run(-1) && resizeCmd.exitCode() == 0)
             rval = true;
         else
             report.line() << xi18nc("@info/plain", "Resizing Btrfs file system on partition <filename>%1</filename> failed: btrfs file system resize failed.", deviceNode);
 
-        ExternalCommand unmountCmd(report, QStringLiteral("umount"), QStringList() << tempDir.path());
+        ExternalCommand unmountCmd(report, QStringLiteral("umount"), { tempDir.path() });
 
         if (!unmountCmd.run(-1) && unmountCmd.exitCode() == 0)
             report.line() << xi18nc("@info/plain", "Warning: Resizing Btrfs file system on partition <filename>%1</filename>: Unmount failed.", deviceNode);
@@ -162,7 +164,7 @@ bool btrfs::resize(Report& report, const QString& deviceNode, qint64 length) con
 
 bool btrfs::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
-    ExternalCommand cmd(report, QStringLiteral("btrfs"), QStringList() << QStringLiteral("filesystem") << QStringLiteral("label") << deviceNode << newLabel);
+    ExternalCommand cmd(report, QStringLiteral("btrfs"), { QStringLiteral("filesystem"), QStringLiteral("label"), deviceNode, newLabel });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
diff --git a/src/fs/exfat.cpp b/src/fs/exfat.cpp
index b3b9929..6406051 100644
--- a/src/fs/exfat.cpp
+++ b/src/fs/exfat.cpp
@@ -95,19 +95,19 @@ qint64 exfat::maxLabelLength() const
 
 bool exfat::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("exfatfsck"), QStringList() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("exfatfsck"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool exfat::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.exfat"), QStringList() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.exfat"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool exfat::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
-    ExternalCommand cmd(report, QStringLiteral("exfatlabel"), QStringList() << deviceNode << newLabel);
+    ExternalCommand cmd(report, QStringLiteral("exfatlabel"), { deviceNode, newLabel });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
diff --git a/src/fs/ext2.cpp b/src/fs/ext2.cpp
index ad318be..3ced65a 100644
--- a/src/fs/ext2.cpp
+++ b/src/fs/ext2.cpp
@@ -50,7 +50,7 @@ void ext2::init()
     m_GetLabel = cmdSupportCore;
     m_SetLabel = findExternal(QStringLiteral("e2label")) ? cmdSupportFileSystem : cmdSupportNone;
     m_Create = findExternal(QStringLiteral("mkfs.ext2")) ? cmdSupportFileSystem : cmdSupportNone;
-    m_Check = findExternal(QStringLiteral("e2fsck"), QStringList() << QStringLiteral("-V")) ? cmdSupportFileSystem : cmdSupportNone;
+    m_Check = findExternal(QStringLiteral("e2fsck"), { QStringLiteral("-V") }) ? cmdSupportFileSystem : cmdSupportNone;
     m_UpdateUUID = findExternal(QStringLiteral("tune2fs")) ? cmdSupportFileSystem : cmdSupportNone;
     m_Grow = (m_Check != cmdSupportNone && findExternal(QStringLiteral("resize2fs"))) ? cmdSupportFileSystem : cmdSupportNone;
     m_Shrink = (m_Grow != cmdSupportNone && m_GetUsed) != cmdSupportNone ? cmdSupportFileSystem : cmdSupportNone;
@@ -94,7 +94,7 @@ qint64 ext2::maxLabelLength() const
 
 qint64 ext2::readUsedCapacity(const QString& deviceNode) const
 {
-    ExternalCommand cmd(QStringLiteral("dumpe2fs"), QStringList() << QStringLiteral("-h") << deviceNode);
+    ExternalCommand cmd(QStringLiteral("dumpe2fs"), { QStringLiteral("-h"), deviceNode });
 
     if (cmd.run()) {
         qint64 blockCount = -1;
@@ -124,32 +124,32 @@ qint64 ext2::readUsedCapacity(const QString& deviceNode) const
 
 bool ext2::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("e2fsck"), QStringList() << QStringLiteral("-f") << QStringLiteral("-y") << QStringLiteral("-v") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("e2fsck"), { QStringLiteral("-f"), QStringLiteral("-y"), QStringLiteral("-v"), deviceNode });
     return cmd.run(-1) && (cmd.exitCode() == 0 || cmd.exitCode() == 1 || cmd.exitCode() == 2 || cmd.exitCode() == 256);
 }
 
 bool ext2::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.ext2"), QStringList() << QStringLiteral("-qF") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.ext2"), { QStringLiteral("-qF"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool ext2::resize(Report& report, const QString& deviceNode, qint64 length) const
 {
     const QString len = QString::number(length / 512) + QStringLiteral("s");
-    ExternalCommand cmd(report, QStringLiteral("resize2fs"), QStringList() << deviceNode << len);
+    ExternalCommand cmd(report, QStringLiteral("resize2fs"), { deviceNode, len });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool ext2::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
-    ExternalCommand cmd(report, QStringLiteral("e2label"), QStringList() << deviceNode << newLabel);
+    ExternalCommand cmd(report, QStringLiteral("e2label"), { deviceNode, newLabel });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool ext2::updateUUID(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("tune2fs"), QStringList() << QStringLiteral("-U") << QStringLiteral("random") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("tune2fs"), { QStringLiteral("-U"), QStringLiteral("random"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 }
diff --git a/src/fs/f2fs.cpp b/src/fs/f2fs.cpp
index 490b1b1..634e75d 100644
--- a/src/fs/f2fs.cpp
+++ b/src/fs/f2fs.cpp
@@ -109,13 +109,13 @@ qint64 f2fs::maxLabelLength() const
 
 bool f2fs::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("fsck.f2fs"), QStringList() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("fsck.f2fs"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool f2fs::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.f2fs"), QStringList() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.f2fs"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
diff --git a/src/fs/fat16.cpp b/src/fs/fat16.cpp
index 39374e3..459c75b 100644
--- a/src/fs/fat16.cpp
+++ b/src/fs/fat16.cpp
@@ -53,7 +53,7 @@ fat16::fat16(qint64 firstsector, qint64 lastsector, qint64 sectorsused, const QS
 void fat16::init()
 {
     m_Create = findExternal(QStringLiteral("mkfs.msdos")) ? cmdSupportFileSystem : cmdSupportNone;
-    m_GetUsed = m_Check = findExternal(QStringLiteral("fsck.msdos"), QStringList(), 2) ? cmdSupportFileSystem : cmdSupportNone;
+    m_GetUsed = m_Check = findExternal(QStringLiteral("fsck.msdos"), {}, 2) ? cmdSupportFileSystem : cmdSupportNone;
     m_GetLabel = cmdSupportCore;
     m_SetLabel = findExternal(QStringLiteral("fatlabel")) ? cmdSupportFileSystem : cmdSupportNone;
     m_Move = cmdSupportCore;
@@ -104,7 +104,7 @@ qint64 fat16::maxLabelLength() const
 
 qint64 fat16::readUsedCapacity(const QString& deviceNode) const
 {
-    ExternalCommand cmd(QStringLiteral("fsck.msdos"), QStringList() << QStringLiteral("-n") << QStringLiteral("-v") << deviceNode);
+    ExternalCommand cmd(QStringLiteral("fsck.msdos"), { QStringLiteral("-n"), QStringLiteral("-v"), deviceNode });
 
     if (cmd.run()) {
         qint64 usedClusters = -1;
@@ -131,19 +131,19 @@ bool fat16::writeLabel(Report& report, const QString& deviceNode, const QString&
 {
     report.line() << xi18nc("@info/plain", "Setting label for partition <filename>%1</filename> to %2", deviceNode, newLabel);
 
-    ExternalCommand cmd(report, QStringLiteral("fatlabel"), QStringList() << deviceNode << newLabel);
+    ExternalCommand cmd(report, QStringLiteral("fatlabel"), { deviceNode, newLabel });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool fat16::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("fsck.msdos"), QStringList() << QStringLiteral("-a") << QStringLiteral("-w") << QStringLiteral("-v") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("fsck.msdos"), { QStringLiteral("-a"), QStringLiteral("-w"), QStringLiteral("-v"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool fat16::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.msdos"), QStringList() << QStringLiteral("-F16") << QStringLiteral("-I") << QStringLiteral("-v") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.msdos"), { QStringLiteral("-F16"), QStringLiteral("-I"), QStringLiteral("-v"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
@@ -155,7 +155,7 @@ bool fat16::updateUUID(Report& report, const QString& deviceNode) const
     for (quint32 i = 0; i < sizeof(uuid); i++, t >>= 8)
         uuid[i] = t & 0xff;
 
-    ExternalCommand cmd(report, QStringLiteral("dd"), QStringList() << QStringLiteral("of=") + deviceNode << QStringLiteral("bs=1") << QStringLiteral("count=4") << QStringLiteral("seek=39"));
+    ExternalCommand cmd(report, QStringLiteral("dd"), { QStringLiteral("of=") + deviceNode , QStringLiteral("bs=1"), QStringLiteral("count=4"), QStringLiteral("seek=39") });
 
     if (!cmd.start())
         return false;
diff --git a/src/fs/fat32.cpp b/src/fs/fat32.cpp
index 38b855c..8ab35b5 100644
--- a/src/fs/fat32.cpp
+++ b/src/fs/fat32.cpp
@@ -42,7 +42,7 @@ qint64 fat32::maxCapacity() const
 
 bool fat32::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.msdos"), QStringList() << QStringLiteral("-F32") << QStringLiteral("-I") << QStringLiteral("-v") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.msdos"), { QStringLiteral("-F32"), QStringLiteral("-I"), QStringLiteral("-v"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
@@ -54,7 +54,7 @@ bool fat32::updateUUID(Report& report, const QString& deviceNode) const
     for (quint32 i = 0; i < sizeof(uuid); i++, t >>= 8)
         uuid[i] = t & 0xff;
 
-    ExternalCommand cmd(report, QStringLiteral("dd"), QStringList() << QStringLiteral("of=") + deviceNode << QStringLiteral("bs=1") << QStringLiteral("count=4") << QStringLiteral("seek=67"));
+    ExternalCommand cmd(report, QStringLiteral("dd"), { QStringLiteral("of=") + deviceNode, QStringLiteral("bs=1"), QStringLiteral("count=4"), QStringLiteral("seek=67") });
 
     if (!cmd.start())
         return false;
diff --git a/src/fs/hfs.cpp b/src/fs/hfs.cpp
index 2da9637..715738d 100644
--- a/src/fs/hfs.cpp
+++ b/src/fs/hfs.cpp
@@ -84,13 +84,13 @@ qint64 hfs::maxLabelLength() const
 
 bool hfs::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("hfsck"), QStringList() << QStringLiteral("-v") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("hfsck"), { QStringLiteral("-v"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool hfs::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("hformat"), QStringList() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("hformat"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 }
diff --git a/src/fs/hfsplus.cpp b/src/fs/hfsplus.cpp
index 3f21941..ff70c19 100644
--- a/src/fs/hfsplus.cpp
+++ b/src/fs/hfsplus.cpp
@@ -79,7 +79,7 @@ qint64 hfsplus::maxLabelLength() const
 
 bool hfsplus::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("hpfsck"), QStringList() << QStringLiteral("-v") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("hpfsck"), { QStringLiteral("-v"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 }
diff --git a/src/fs/jfs.cpp b/src/fs/jfs.cpp
index d9fc2cc..0e664d1 100644
--- a/src/fs/jfs.cpp
+++ b/src/fs/jfs.cpp
@@ -50,9 +50,9 @@ void jfs::init()
 {
     m_GetUsed = findExternal(QStringLiteral("jfs_debugfs")) ? cmdSupportFileSystem : cmdSupportNone;
     m_GetLabel = cmdSupportCore;
-    m_SetLabel = findExternal(QStringLiteral("jfs_tune"), QStringList() << QStringLiteral("-V")) ? cmdSupportFileSystem : cmdSupportNone;
-    m_Create = findExternal(QStringLiteral("mkfs.jfs"), QStringList() << QStringLiteral("-V")) ? cmdSupportFileSystem : cmdSupportNone;
-    m_Grow = m_Check = findExternal(QStringLiteral("fsck.jfs"), QStringList() << QStringLiteral("-V")) ? cmdSupportFileSystem : cmdSupportNone;
+    m_SetLabel = findExternal(QStringLiteral("jfs_tune"), { QStringLiteral("-V") }) ? cmdSupportFileSystem : cmdSupportNone;
+    m_Create = findExternal(QStringLiteral("mkfs.jfs"),{ QStringLiteral("-V") }) ? cmdSupportFileSystem : cmdSupportNone;
+    m_Grow = m_Check = findExternal(QStringLiteral("fsck.jfs"), { QStringLiteral("-V") }) ? cmdSupportFileSystem : cmdSupportNone;
     m_Copy = m_Move = (m_Check != cmdSupportNone) ? cmdSupportCore : cmdSupportNone;
     m_Backup = cmdSupportCore;
 }
@@ -133,19 +133,19 @@ qint64 jfs::readUsedCapacity(const QString& deviceNode) const
 
 bool jfs::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
-    ExternalCommand cmd(report, QStringLiteral("jfs_tune"), QStringList() << QStringLiteral("-L") << newLabel << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("jfs_tune"), { QStringLiteral("-L"), newLabel, deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool jfs::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("fsck.jfs"), QStringList() << QStringLiteral("-f") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("fsck.jfs"), { QStringLiteral("-f"), deviceNode });
     return cmd.run(-1) && (cmd.exitCode() == 0 || cmd.exitCode() == 1);
 }
 
 bool jfs::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.jfs"), QStringList() << QStringLiteral("-q") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.jfs"), { QStringLiteral("-q"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
@@ -159,17 +159,17 @@ bool jfs::resize(Report& report, const QString& deviceNode, qint64) const
 
     bool rval = false;
 
-    ExternalCommand mountCmd(report, QStringLiteral("mount"), QStringList() << QStringLiteral("-v") << QStringLiteral("-t") << QStringLiteral("jfs") << deviceNode << tempDir.path());
+    ExternalCommand mountCmd(report, QStringLiteral("mount"), { QStringLiteral("-v"), QStringLiteral("-t"), QStringLiteral("jfs"), deviceNode, tempDir.path() });
 
     if (mountCmd.run(-1)) {
-        ExternalCommand resizeMountCmd(report, QStringLiteral("mount"), QStringList() << QStringLiteral("-v") << QStringLiteral("-t") << QStringLiteral("jfs") << QStringLiteral("-o") << QStringLiteral("remount,resize") << deviceNode << tempDir.path());
+        ExternalCommand resizeMountCmd(report, QStringLiteral("mount"), { QStringLiteral("-v"), QStringLiteral("-t"), QStringLiteral("jfs"), QStringLiteral("-o"), QStringLiteral("remount,resize"), deviceNode, tempDir.path() });
 
         if (resizeMountCmd.run(-1))
             rval = true;
         else
             report.line() << xi18nc("@info/plain", "Resizing JFS file system on partition <filename>%1</filename> failed: Remount failed.", deviceNode);
 
-        ExternalCommand unmountCmd(report, QStringLiteral("umount"), QStringList() << tempDir.path());
+        ExternalCommand unmountCmd(report, QStringLiteral("umount"), { tempDir.path() });
 
         if (!unmountCmd.run(-1))
             report.line() << xi18nc("@info/plain", "Warning: Resizing JFS file system on partition <filename>%1</filename>: Unmount failed.", deviceNode);
diff --git a/src/fs/linuxswap.cpp b/src/fs/linuxswap.cpp
index 0b68d36..44fda2e 100644
--- a/src/fs/linuxswap.cpp
+++ b/src/fs/linuxswap.cpp
@@ -77,7 +77,7 @@ qint64 linuxswap::maxLabelLength() const
 
 bool linuxswap::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkswap"), QStringList() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkswap"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
@@ -117,7 +117,7 @@ bool linuxswap::copy(Report& report, const QString& targetDeviceNode, const QStr
 
 bool linuxswap::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
-    ExternalCommand cmd(report, QStringLiteral("mkswap"), QStringList() << QStringLiteral("--label") << newLabel << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkswap"), { QStringLiteral("--label"), newLabel, deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
@@ -133,13 +133,13 @@ QString linuxswap::unmountTitle() const
 
 bool linuxswap::mount(const QString& deviceNode)
 {
-    ExternalCommand cmd(QStringLiteral("swapon"), QStringList() << deviceNode);
+    ExternalCommand cmd(QStringLiteral("swapon"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool linuxswap::unmount(const QString& deviceNode)
 {
-    ExternalCommand cmd(QStringLiteral("swapoff"), QStringList() << deviceNode);
+    ExternalCommand cmd(QStringLiteral("swapoff"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
diff --git a/src/fs/lvm2_pv.cpp b/src/fs/lvm2_pv.cpp
index e42d6fd..5af3c7c 100644
--- a/src/fs/lvm2_pv.cpp
+++ b/src/fs/lvm2_pv.cpp
@@ -88,26 +88,26 @@ qint64 lvm2_pv::maxCapacity() const
 
 bool lvm2_pv::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("lvm"), QStringList() << QStringLiteral("pvck") << QStringLiteral("--verbose") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("lvm"), { QStringLiteral("pvck"), QStringLiteral("--verbose"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool lvm2_pv::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("lvm"), QStringList() << QStringLiteral("pvcreate") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("lvm"), { QStringLiteral("pvcreate"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool lvm2_pv::remove(Report& report, const QString& deviceNode) const
 {
 //      TODO: check if PV is a member of an exported VG
-    ExternalCommand cmd(report, QStringLiteral("lvm"), QStringList() << QStringLiteral("pvremove") << QStringLiteral("--force") << QStringLiteral("--force") << QStringLiteral("--yes") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("lvm"), { QStringLiteral("pvremove"), QStringLiteral("--force"), QStringLiteral("--force"), QStringLiteral("--yes"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool lvm2_pv::updateUUID(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("lvm"), QStringList() << QStringLiteral("pvchange") << QStringLiteral("--uuid") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("lvm"), { QStringLiteral("pvchange"), QStringLiteral("--uuid"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 }
diff --git a/src/fs/nilfs2.cpp b/src/fs/nilfs2.cpp
index 67f18a8..38da68f 100644
--- a/src/fs/nilfs2.cpp
+++ b/src/fs/nilfs2.cpp
@@ -110,19 +110,19 @@ qint64 nilfs2::maxLabelLength() const
 
 bool nilfs2::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("fsck.nilfs2"), QStringList() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("fsck.nilfs2"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool nilfs2::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.nilfs2"), QStringList() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.nilfs2"), { deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 qint64 nilfs2::readUsedCapacity(const QString& deviceNode) const
 {
-    ExternalCommand cmd(QStringLiteral("nilfs-tune"), QStringList() << QStringLiteral("-l") << deviceNode);
+    ExternalCommand cmd(QStringLiteral("nilfs-tune"), { QStringLiteral("-l"), deviceNode });
 
     if (cmd.run()) {
         QRegExp rxBlockSize(QStringLiteral("(?:Block size:\\s+)(\\d+)"));
@@ -145,17 +145,17 @@ bool nilfs2::resize(Report& report, const QString& deviceNode, qint64 length) co
 
     bool rval = false;
 
-    ExternalCommand mountCmd(report, QStringLiteral("mount"), QStringList() << QStringLiteral("--verbose") << QStringLiteral("--types") << QStringLiteral("nilfs2") << deviceNode << tempDir.path());
+    ExternalCommand mountCmd(report, QStringLiteral("mount"), { QStringLiteral("--verbose"), QStringLiteral("--types"), QStringLiteral("nilfs2"), deviceNode, tempDir.path() });
 
     if (mountCmd.run(-1) && mountCmd.exitCode() == 0) {
-        ExternalCommand resizeCmd(report, QStringLiteral("nilfs-resize"), QStringList() << QStringLiteral("--verbose") << QStringLiteral("--assume-yes") << deviceNode << QString::number(length));
+        ExternalCommand resizeCmd(report, QStringLiteral("nilfs-resize"), { QStringLiteral("--verbose"), QStringLiteral("--assume-yes"), deviceNode, QString::number(length) });
 
         if (resizeCmd.run(-1) && resizeCmd.exitCode() == 0)
             rval = true;
         else
             report.line() << xi18nc("@info/plain", "Resizing NILFS2 file system on partition <filename>%1</filename> failed: NILFS2 file system resize failed.", deviceNode);
 
-        ExternalCommand unmountCmd(report, QStringLiteral("umount"), QStringList() << tempDir.path());
+        ExternalCommand unmountCmd(report, QStringLiteral("umount"), { tempDir.path() });
 
         if (!unmountCmd.run(-1) && unmountCmd.exitCode() == 0)
             report.line() << xi18nc("@info/plain", "Warning: Resizing NILFS2 file system on partition <filename>%1</filename>: Unmount failed.", deviceNode);
@@ -167,14 +167,14 @@ bool nilfs2::resize(Report& report, const QString& deviceNode, qint64 length) co
 
 bool nilfs2::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
-    ExternalCommand cmd(report, QStringLiteral("nilfs-tune"), QStringList() << QStringLiteral("-l") << newLabel << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("nilfs-tune"), { QStringLiteral("-l"), newLabel, deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool nilfs2::updateUUID(Report& report, const QString& deviceNode) const
 {
     QUuid uuid = QUuid::createUuid();
-    ExternalCommand cmd(report, QStringLiteral("nilfs-tune"), QStringList() << QStringLiteral("-U") << uuid.toString() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("nilfs-tune"), { QStringLiteral("-U"), uuid.toString(), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 }
diff --git a/src/fs/ntfs.cpp b/src/fs/ntfs.cpp
index 421ae23..7665017 100644
--- a/src/fs/ntfs.cpp
+++ b/src/fs/ntfs.cpp
@@ -105,7 +105,7 @@ qint64 ntfs::maxLabelLength() const
 
 qint64 ntfs::readUsedCapacity(const QString& deviceNode) const
 {
-    ExternalCommand cmd(QStringLiteral("ntfsresize"), QStringList() << QStringLiteral("--info") << QStringLiteral("--force") << QStringLiteral("--no-progress-bar") << deviceNode);
+    ExternalCommand cmd(QStringLiteral("ntfsresize"), { QStringLiteral("--info"), QStringLiteral("--force"), QStringLiteral("--no-progress-bar"), deviceNode });
 
     if (cmd.run()) {
         qint64 usedBytes = -1;
@@ -123,13 +123,13 @@ qint64 ntfs::readUsedCapacity(const QString& deviceNode) const
 
 bool ntfs::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
-    ExternalCommand writeCmd(report, QStringLiteral("ntfslabel"), QStringList() << QStringLiteral("--force") << deviceNode << newLabel.simplified());
+    ExternalCommand writeCmd(report, QStringLiteral("ntfslabel"), { QStringLiteral("--force"), deviceNode, newLabel.simplified() });
     writeCmd.setProcessChannelMode(QProcess::SeparateChannels);
 
     if (!writeCmd.run(-1))
         return false;
 
-    ExternalCommand testCmd(QStringLiteral("ntfslabel"), QStringList() << QStringLiteral("--force") << deviceNode);
+    ExternalCommand testCmd(QStringLiteral("ntfslabel"), { QStringLiteral("--force"), deviceNode });
     testCmd.setProcessChannelMode(QProcess::SeparateChannels);
 
     if (!testCmd.run(-1))
@@ -140,27 +140,26 @@ bool ntfs::writeLabel(Report& report, const QString& deviceNode, const QString&
 
 bool ntfs::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("ntfsresize"), QStringList() << QStringLiteral("--no-progress-bar") << QStringLiteral("--info") << QStringLiteral("--force") << QStringLiteral("--verbose") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("ntfsresize"), { QStringLiteral("--no-progress-bar"), QStringLiteral("--info"), QStringLiteral("--force"), QStringLiteral("--verbose"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool ntfs::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.ntfs"), QStringList() << QStringLiteral("--quick") << QStringLiteral("--verbose") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.ntfs"), { QStringLiteral("--quick"), QStringLiteral("--verbose"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool ntfs::copy(Report& report, const QString& targetDeviceNode, const QString& sourceDeviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("ntfsclone"), QStringList() << QStringLiteral("--force") << QStringLiteral("--overwrite") << targetDeviceNode << sourceDeviceNode);
+    ExternalCommand cmd(report, QStringLiteral("ntfsclone"), { QStringLiteral("--force"), QStringLiteral("--overwrite"), targetDeviceNode, sourceDeviceNode });
 
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool ntfs::resize(Report& report, const QString& deviceNode, qint64 length) const
 {
-    QStringList args;
-    args << QStringLiteral("--no-progress-bar") << QStringLiteral("--force") << deviceNode << QStringLiteral("--size") << QString::number(length);
+    QStringList args = { QStringLiteral("--no-progress-bar"), QStringLiteral("--force"), deviceNode, QStringLiteral("--size"), QString::number(length) };
 
     QStringList dryRunArgs = args;
     dryRunArgs << QStringLiteral("--no-action");
diff --git a/src/fs/ocfs2.cpp b/src/fs/ocfs2.cpp
index 60f7f86..53c25f8 100644
--- a/src/fs/ocfs2.cpp
+++ b/src/fs/ocfs2.cpp
@@ -46,16 +46,16 @@ ocfs2::ocfs2(qint64 firstsector, qint64 lastsector, qint64 sectorsused, const QS
 
 void ocfs2::init()
 {
-    m_Create = findExternal(QStringLiteral("mkfs.ocfs2"), QStringList() << QStringLiteral("--version")) ? cmdSupportFileSystem : cmdSupportNone;
-    m_Check = findExternal(QStringLiteral("fsck.ocfs2"), QStringList(), 16) ? cmdSupportFileSystem : cmdSupportNone;
-    m_Grow = (m_Check != cmdSupportNone && findExternal(QStringLiteral("tunefs.ocfs2"), QStringList() << QStringLiteral("--version")) && findExternal(QStringLiteral("debugfs.ocfs2"), QStringList() << QStringLiteral("--version"))) ? cmdSupportFileSystem : cmdSupportNone;
+    m_Create = findExternal(QStringLiteral("mkfs.ocfs2"), { QStringLiteral("--version") }) ? cmdSupportFileSystem : cmdSupportNone;
+    m_Check = findExternal(QStringLiteral("fsck.ocfs2"), {}, 16) ? cmdSupportFileSystem : cmdSupportNone;
+    m_Grow = (m_Check != cmdSupportNone && findExternal(QStringLiteral("tunefs.ocfs2"), { QStringLiteral("--version") }) && findExternal(QStringLiteral("debugfs.ocfs2"), { QStringLiteral("--version") })) ? cmdSupportFileSystem : cmdSupportNone;
     m_Shrink = cmdSupportNone;
 
     // TODO: it seems there's no way to get the FS usage with ocfs2
     m_GetUsed = cmdSupportNone;
 
-    m_SetLabel = findExternal(QStringLiteral("tunefs.ocfs2"), QStringList() << QStringLiteral("--version")) ? cmdSupportFileSystem : cmdSupportNone;
-    m_UpdateUUID = findExternal(QStringLiteral("tunefs.ocfs2"), QStringList() << QStringLiteral("--version")) ? cmdSupportFileSystem : cmdSupportNone;
+    m_SetLabel = findExternal(QStringLiteral("tunefs.ocfs2"), { QStringLiteral("--version") }) ? cmdSupportFileSystem : cmdSupportNone;
+    m_UpdateUUID = findExternal(QStringLiteral("tunefs.ocfs2"), { QStringLiteral("--version") }) ? cmdSupportFileSystem : cmdSupportNone;
 
     m_Copy = (m_Check != cmdSupportNone) ? cmdSupportCore : cmdSupportNone;
     m_Move = (m_Check != cmdSupportNone) ? cmdSupportCore : cmdSupportNone;
@@ -105,13 +105,13 @@ qint64 ocfs2::readUsedCapacity(const QString& deviceNode) const
 
 bool ocfs2::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("fsck.ocfs2"), QStringList() << QStringLiteral("-f") << QStringLiteral("-y") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("fsck.ocfs2"), { QStringLiteral("-f"), QStringLiteral("-y"), deviceNode });
     return cmd.run(-1) && (cmd.exitCode() == 0 || cmd.exitCode() == 1 || cmd.exitCode() == 2);
 }
 
 bool ocfs2::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.ocfs2"), QStringList() << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.ocfs2"), { deviceNode });
 
     if (cmd.start())
     {
@@ -126,7 +126,7 @@ bool ocfs2::create(Report& report, const QString& deviceNode) const
 
 bool ocfs2::resize(Report& report, const QString& deviceNode, qint64 length) const
 {
-    ExternalCommand cmdBlockSize(QStringLiteral("debugfs.ocfs2"), QStringList() << QStringLiteral("--request") << QStringLiteral("stats") << deviceNode);
+    ExternalCommand cmdBlockSize(QStringLiteral("debugfs.ocfs2"), { QStringLiteral("--request"), QStringLiteral("stats"), deviceNode });
 
     qint32 blockSize = -1;
     if (cmdBlockSize.run()) {
@@ -139,19 +139,19 @@ bool ocfs2::resize(Report& report, const QString& deviceNode, qint64 length) con
     if (blockSize == -1)
         return false;
 
-    ExternalCommand cmd(report, QStringLiteral("tunefs.ocfs2"), QStringList() << QStringLiteral("--yes") << QStringLiteral("--volume-size") << deviceNode << QString::number(length / blockSize));
+    ExternalCommand cmd(report, QStringLiteral("tunefs.ocfs2"), { QStringLiteral("--yes"), QStringLiteral("--volume-size"), deviceNode, QString::number(length / blockSize) });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool ocfs2::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
-    ExternalCommand cmd(report, QStringLiteral("tunefs.ocfs2"), QStringList() << QStringLiteral("--label") << newLabel << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("tunefs.ocfs2"), { QStringLiteral("--label"), newLabel, deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool ocfs2::updateUUID(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("tunefs.ocfs2"), QStringList() << QStringLiteral("--uuid-reset") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("tunefs.ocfs2"), { QStringLiteral("--uuid-reset"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 }
diff --git a/src/fs/reiser4.cpp b/src/fs/reiser4.cpp
index aa1b105..ce70981 100644
--- a/src/fs/reiser4.cpp
+++ b/src/fs/reiser4.cpp
@@ -42,9 +42,9 @@ reiser4::reiser4(qint64 firstsector, qint64 lastsector, qint64 sectorsused, cons
 void reiser4::init()
 {
     m_GetLabel = cmdSupportCore;
-    m_GetUsed = findExternal(QStringLiteral("debugfs.reiser4"), QStringList(), 16) ? cmdSupportFileSystem : cmdSupportNone;
-    m_Create = findExternal(QStringLiteral("mkfs.reiser4"), QStringList(), 16) ? cmdSupportFileSystem : cmdSupportNone;
-    m_Check = findExternal(QStringLiteral("fsck.reiser4"), QStringList(), 16) ? cmdSupportFileSystem : cmdSupportNone;
+    m_GetUsed = findExternal(QStringLiteral("debugfs.reiser4"), {}, 16) ? cmdSupportFileSystem : cmdSupportNone;
+    m_Create = findExternal(QStringLiteral("mkfs.reiser4"), {}, 16) ? cmdSupportFileSystem : cmdSupportNone;
+    m_Check = findExternal(QStringLiteral("fsck.reiser4"), {}, 16) ? cmdSupportFileSystem : cmdSupportNone;
     m_Move = m_Copy = (m_Check != cmdSupportNone) ? cmdSupportCore : cmdSupportNone;
     m_Backup = cmdSupportCore;
 }
@@ -85,7 +85,7 @@ qint64 reiser4::maxLabelLength() const
 
 qint64 reiser4::readUsedCapacity(const QString& deviceNode) const
 {
-    ExternalCommand cmd(QStringLiteral("debugfs.reiser4"), QStringList() << deviceNode);
+    ExternalCommand cmd(QStringLiteral("debugfs.reiser4"), { deviceNode });
 
     if (cmd.run()) {
         qint64 blocks = -1;
@@ -115,13 +115,13 @@ qint64 reiser4::readUsedCapacity(const QString& deviceNode) const
 
 bool reiser4::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("fsck.reiser4"), QStringList() << QStringLiteral("--fix") << QStringLiteral("--yes") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("fsck.reiser4"), { QStringLiteral("--yes"), QStringLiteral("--fix"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool reiser4::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.reiser4"), QStringList() << QStringLiteral("--force") << QStringLiteral("--yes") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.reiser4"), { QStringLiteral("--yes"), QStringLiteral("--force"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 }
diff --git a/src/fs/reiserfs.cpp b/src/fs/reiserfs.cpp
index cbf10e3..337969c 100644
--- a/src/fs/reiserfs.cpp
+++ b/src/fs/reiserfs.cpp
@@ -49,12 +49,12 @@ reiserfs::reiserfs(qint64 firstsector, qint64 lastsector, qint64 sectorsused, co
 void reiserfs::init()
 {
     m_GetLabel = cmdSupportCore;
-    m_GetUsed = findExternal(QStringLiteral("debugreiserfs"), QStringList(), 16) ? cmdSupportFileSystem : cmdSupportNone;
+    m_GetUsed = findExternal(QStringLiteral("debugreiserfs"), {}, 16) ? cmdSupportFileSystem : cmdSupportNone;
     m_SetLabel = findExternal(QStringLiteral("reiserfstune")) ? cmdSupportFileSystem : cmdSupportNone;
     m_Create = findExternal(QStringLiteral("mkfs.reiserfs")) ? cmdSupportFileSystem : cmdSupportNone;
     m_Check = findExternal(QStringLiteral("fsck.reiserfs")) ? cmdSupportFileSystem : cmdSupportNone;
     m_Move = m_Copy = (m_Check != cmdSupportNone) ? cmdSupportCore : cmdSupportNone;
-    m_Grow = findExternal(QStringLiteral("resize_reiserfs"), QStringList(), 16) ? cmdSupportFileSystem : cmdSupportNone;
+    m_Grow = findExternal(QStringLiteral("resize_reiserfs"), {}, 16) ? cmdSupportFileSystem : cmdSupportNone;
     m_Shrink = (m_GetUsed != cmdSupportNone && m_Grow != cmdSupportNone) ? cmdSupportFileSystem : cmdSupportNone;
     m_Backup = cmdSupportCore;
     m_UpdateUUID = findExternal(QStringLiteral("reiserfstune")) ? cmdSupportFileSystem : cmdSupportNone;
@@ -100,7 +100,7 @@ qint64 reiserfs::maxLabelLength() const
 
 qint64 reiserfs::readUsedCapacity(const QString& deviceNode) const
 {
-    ExternalCommand cmd(QStringLiteral("debugreiserfs"), QStringList() << deviceNode);
+    ExternalCommand cmd(QStringLiteral("debugreiserfs"), { deviceNode });
 
     if (cmd.run()) {
         qint64 blockCount = -1;
@@ -130,25 +130,25 @@ qint64 reiserfs::readUsedCapacity(const QString& deviceNode) const
 
 bool reiserfs::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
-    ExternalCommand cmd(report, QStringLiteral("reiserfstune"), QStringList() << QStringLiteral("--label") << newLabel << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("reiserfstune"), { QStringLiteral("--label"), newLabel, deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool reiserfs::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("fsck.reiserfs"), QStringList() << QStringLiteral("--fix-fixable") << QStringLiteral("--quiet") << QStringLiteral("--yes") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("fsck.reiserfs"), { QStringLiteral("--fix-fixable"), QStringLiteral("--quiet"), QStringLiteral("--yes"), deviceNode });
     return cmd.run(-1) && (cmd.exitCode() == 0 || cmd.exitCode() == 1 || cmd.exitCode() == 256);
 }
 
 bool reiserfs::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.reiserfs"), QStringList() << QStringLiteral("-f") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.reiserfs"), { QStringLiteral("-f"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool reiserfs::resize(Report& report, const QString& deviceNode, qint64 length) const
 {
-    ExternalCommand cmd(report, QStringLiteral("resize_reiserfs"), QStringList() << deviceNode << QStringLiteral("-q") << QStringLiteral("-s") << QString::number(length));
+    ExternalCommand cmd(report, QStringLiteral("resize_reiserfs"), { deviceNode, QStringLiteral("-q"), QStringLiteral("-s"), QString::number(length) });
 
     bool rval = cmd.start(-1);
 
@@ -164,7 +164,7 @@ bool reiserfs::resize(Report& report, const QString& deviceNode, qint64 length)
 bool reiserfs::updateUUID(Report& report, const QString& deviceNode) const
 {
     const QString uuid = QUuid::createUuid().toString().remove(QRegExp(QStringLiteral("\\{|\\}")));
-    ExternalCommand cmd(report, QStringLiteral("reiserfstune"), QStringList() << QStringLiteral("--uuid") << uuid << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("reiserfstune"), { QStringLiteral("--uuid"), uuid, deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 }
diff --git a/src/fs/xfs.cpp b/src/fs/xfs.cpp
index 4d0e366..949d280 100644
--- a/src/fs/xfs.cpp
+++ b/src/fs/xfs.cpp
@@ -55,7 +55,7 @@ void xfs::init()
     m_Create = findExternal(QStringLiteral("mkfs.xfs")) ? cmdSupportFileSystem : cmdSupportNone;
 
     m_Check = findExternal(QStringLiteral("xfs_repair")) ? cmdSupportFileSystem : cmdSupportNone;
-    m_Grow = (findExternal(QStringLiteral("xfs_growfs"), QStringList() << QStringLiteral("-V")) && m_Check != cmdSupportNone) ? cmdSupportFileSystem : cmdSupportNone;
+    m_Grow = (findExternal(QStringLiteral("xfs_growfs"), { QStringLiteral("-V") }) && m_Check != cmdSupportNone) ? cmdSupportFileSystem : cmdSupportNone;
     m_Copy = findExternal(QStringLiteral("xfs_copy")) ? cmdSupportFileSystem : cmdSupportNone;
     m_Move = (m_Check != cmdSupportNone) ? cmdSupportCore : cmdSupportNone;
     m_Backup = cmdSupportCore;
@@ -100,7 +100,7 @@ qint64 xfs::maxLabelLength() const
 
 qint64 xfs::readUsedCapacity(const QString& deviceNode) const
 {
-    ExternalCommand cmd(QStringLiteral("xfs_db"), QStringList() << QStringLiteral("-c") << QStringLiteral("sb 0") << QStringLiteral("-c") << QStringLiteral("print") << deviceNode);
+    ExternalCommand cmd(QStringLiteral("xfs_db"), { QStringLiteral("-c"), QStringLiteral("sb 0"), QStringLiteral("-c"), QStringLiteral("print"), deviceNode });
 
     if (cmd.run()) {
         qint64 dBlocks = -1;
@@ -130,25 +130,25 @@ qint64 xfs::readUsedCapacity(const QString& deviceNode) const
 
 bool xfs::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
-    ExternalCommand cmd(report, QStringLiteral("xfs_db"), QStringList() << QStringLiteral("-x") << QStringLiteral("-c") << QStringLiteral("sb 0") << QStringLiteral("-c") << QStringLiteral("label ") + newLabel << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("xfs_db"), { QStringLiteral("-x"), QStringLiteral("-c"), QStringLiteral("sb 0"), QStringLiteral("-c"), QStringLiteral("label ") + newLabel, deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool xfs::check(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("xfs_repair"), QStringList() << QStringLiteral("-v") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("xfs_repair"), { QStringLiteral("-v"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool xfs::create(Report& report, const QString& deviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("mkfs.xfs"), QStringList() << QStringLiteral("-f") << deviceNode);
+    ExternalCommand cmd(report, QStringLiteral("mkfs.xfs"), { QStringLiteral("-f"), deviceNode });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool xfs::copy(Report& report, const QString& targetDeviceNode, const QString& sourceDeviceNode) const
 {
-    ExternalCommand cmd(report, QStringLiteral("xfs_copy"), QStringList() << sourceDeviceNode << targetDeviceNode);
+    ExternalCommand cmd(report, QStringLiteral("xfs_copy"), { sourceDeviceNode, targetDeviceNode });
 
     // xfs_copy behaves a little strangely. It apparently kills itself at the end of main, causing QProcess
     // to report that it crashed.
@@ -169,17 +169,17 @@ bool xfs::resize(Report& report, const QString& deviceNode, qint64) const
 
     bool rval = false;
 
-    ExternalCommand mountCmd(report, QStringLiteral("mount"), QStringList() << QStringLiteral("-v") << QStringLiteral("-t") << QStringLiteral("xfs") << deviceNode << tempDir.path());
+    ExternalCommand mountCmd(report, QStringLiteral("mount"), { QStringLiteral("--verbose"), QStringLiteral("--types"), QStringLiteral("xfs"), deviceNode, tempDir.path() });
 
     if (mountCmd.run(-1)) {
-        ExternalCommand resizeCmd(report, QStringLiteral("xfs_growfs"), QStringList() << tempDir.path());
+        ExternalCommand resizeCmd(report, QStringLiteral("xfs_growfs"), { tempDir.path() });
 
         if (resizeCmd.run(-1))
             rval = true;
         else
             report.line() << xi18nc("@info/plain", "Resizing XFS file system on partition <filename>%1</filename> failed: xfs_growfs failed.", deviceNode);
 
-        ExternalCommand unmountCmd(report, QStringLiteral("umount"), QStringList() << tempDir.path());
+        ExternalCommand unmountCmd(report, QStringLiteral("umount"), { tempDir.path() });
 
         if (!unmountCmd.run(-1))
             report.line() << xi18nc("@info/plain", "Warning: Resizing XFS file system on partition <filename>%1</filename>: Unmount failed.", deviceNode);
diff --git a/src/fs/zfs.cpp b/src/fs/zfs.cpp
index 32d6093..7cc56ce 100644
--- a/src/fs/zfs.cpp
+++ b/src/fs/zfs.cpp
@@ -46,7 +46,7 @@ zfs::zfs(qint64 firstsector, qint64 lastsector, qint64 sectorsused, const QStrin
 
 void zfs::init()
 {
-    m_SetLabel = findExternal(QStringLiteral("zpool"), QStringList(), 2) ? cmdSupportFileSystem : cmdSupportNone;
+    m_SetLabel = findExternal(QStringLiteral("zpool"), {}, 2) ? cmdSupportFileSystem : cmdSupportNone;
 
     m_GetLabel = cmdSupportCore;
     m_Backup = cmdSupportCore;
@@ -88,16 +88,15 @@ qint64 zfs::maxCapacity() const
 bool zfs::remove(Report& report, const QString& deviceNode) const
 {
     Q_UNUSED(deviceNode)
-//      TODO: check if -f option is needed
-    ExternalCommand cmd(report, QStringLiteral("zpool"), QStringList() << QStringLiteral("destroy") << QStringLiteral("-f") << this->label());
+    ExternalCommand cmd(report, QStringLiteral("zpool"), { QStringLiteral("destroy"), QStringLiteral("-f"), this->label() });
     return cmd.run(-1) && cmd.exitCode() == 0;
 }
 
 bool zfs::writeLabel(Report& report, const QString& deviceNode, const QString& newLabel)
 {
     Q_UNUSED(deviceNode)
-    ExternalCommand cmd1(report, QStringLiteral("zpool"), QStringList() << QStringLiteral("export") << this->label());
-    ExternalCommand cmd2(report, QStringLiteral("zpool"), QStringList() << QStringLiteral("import") << this->label() << newLabel);
+    ExternalCommand cmd1(report, QStringLiteral("zpool"), { QStringLiteral("export"), this->label() });
+    ExternalCommand cmd2(report, QStringLiteral("zpool"), { QStringLiteral("import"), this->label(), newLabel });
     return cmd1.run(-1) && cmd1.exitCode() == 0 && cmd2.run(-1) && cmd2.exitCode() == 0;
 }
 }