diff --git a/tests/src/collectionbackend_test.cpp b/tests/src/collectionbackend_test.cpp
index dcac0d29..09acfbad 100644
--- a/tests/src/collectionbackend_test.cpp
+++ b/tests/src/collectionbackend_test.cpp
@@ -47,14 +47,14 @@ class CollectionBackendTest : public ::testing::Test {
   void SetUp() override {
     database_.reset(new MemoryDatabase(nullptr));
     backend_ = make_unique<CollectionBackend>();
-    backend_->Init(database_, nullptr, Song::Source::Collection, SCollection::kSongsTable, SCollection::kFtsTable, SCollection::kDirsTable, SCollection::kSubdirsTable);
+    backend_->Init(database_, nullptr, Song::Source::Collection, QLatin1String(SCollection::kSongsTable), QLatin1String(SCollection::kFtsTable), QLatin1String(SCollection::kDirsTable), QLatin1String(SCollection::kSubdirsTable));
   }
 
   static Song MakeDummySong(int directory_id) {
     // Returns a valid song with all the required fields set
     Song ret;
     ret.set_directory_id(directory_id);
-    ret.set_url(QUrl::fromLocalFile("foo.flac"));
+    ret.set_url(QUrl::fromLocalFile(QLatin1String("foo.flac")));
     ret.set_mtime(1);
     ret.set_ctime(1);
     ret.set_filesize(1);
@@ -80,12 +80,12 @@ TEST_F(CollectionBackendTest, AddDirectory) {
 
   QSignalSpy spy(&*backend_, &CollectionBackend::DirectoryDiscovered);
 
-  backend_->AddDirectory("/tmp");
+  backend_->AddDirectory(QStringLiteral("/tmp"));
 
   // Check the signal was emitted correctly
   ASSERT_EQ(1, spy.count());
   CollectionDirectory dir = spy[0][0].value<CollectionDirectory>();
-  EXPECT_EQ(QFileInfo("/tmp").canonicalFilePath(), dir.path);
+  EXPECT_EQ(QFileInfo(QStringLiteral("/tmp")).canonicalFilePath(), dir.path);
   EXPECT_EQ(1, dir.id);
   EXPECT_EQ(0, spy[0][1].value<CollectionSubdirectoryList>().size());
 
@@ -96,7 +96,7 @@ TEST_F(CollectionBackendTest, RemoveDirectory) {
   // Add a directory
   CollectionDirectory dir;
   dir.id = 1;
-  dir.path = "/tmp";
+  dir.path = QStringLiteral("/tmp");
   backend_->AddDirectory(dir.path);
 
   QSignalSpy spy(&*backend_, &CollectionBackend::DirectoryDeleted);
@@ -107,7 +107,7 @@ TEST_F(CollectionBackendTest, RemoveDirectory) {
   // Check the signal was emitted correctly
   ASSERT_EQ(1, spy.count());
   dir = spy[0][0].value<CollectionDirectory>();
-  EXPECT_EQ("/tmp", dir.path);
+  EXPECT_EQ(QStringLiteral("/tmp"), dir.path);
   EXPECT_EQ(1, dir.id);
 
 }
@@ -121,14 +121,14 @@ class SingleSong : public CollectionBackendTest {
     CollectionBackendTest::SetUp();
 
     // Add a directory - this will get ID 1
-    backend_->AddDirectory("/tmp");
+    backend_->AddDirectory(QStringLiteral("/tmp"));
 
     // Make a song in that directory
     song_ = MakeDummySong(1);
-    song_.set_title("Title");
-    song_.set_artist("Artist");
-    song_.set_album("Album");
-    song_.set_url(QUrl::fromLocalFile("foo.flac"));
+    song_.set_title(QStringLiteral("Title"));
+    song_.set_artist(QStringLiteral("Artist"));
+    song_.set_album(QStringLiteral("Album"));
+    song_.set_url(QUrl::fromLocalFile(QStringLiteral("foo.flac")));
   }
 
   void AddDummySong() {
@@ -157,15 +157,15 @@ class SingleSong : public CollectionBackendTest {
 
 TEST_F(SingleSong, GetSongWithNoAlbum) {
 
-  song_.set_album("");
+  song_.set_album(QLatin1String(""));
   AddDummySong();
   if (HasFatalFailure()) return;
 
   EXPECT_EQ(1, backend_->GetAllArtists().size());
   CollectionBackend::AlbumList albums = backend_->GetAllAlbums();
   EXPECT_EQ(1, albums.size());
-  EXPECT_EQ("Artist", albums[0].album_artist);
-  EXPECT_EQ("", albums[0].album);
+  EXPECT_EQ(QStringLiteral("Artist"), albums[0].album_artist);
+  EXPECT_EQ(QLatin1String(""), albums[0].album);
 
 }
 
@@ -197,7 +197,7 @@ TEST_F(SingleSong, GetAlbumsByArtist) {
   AddDummySong();
   if (HasFatalFailure()) return;
 
-  CollectionBackend::AlbumList albums = backend_->GetAlbumsByArtist("Artist");
+  CollectionBackend::AlbumList albums = backend_->GetAlbumsByArtist(QStringLiteral("Artist"));
   ASSERT_EQ(1, albums.size());
   EXPECT_EQ(song_.album(), albums[0].album);
   EXPECT_EQ(song_.artist(), albums[0].album_artist);
@@ -209,7 +209,7 @@ TEST_F(SingleSong, GetAlbumArt) {
   AddDummySong();
   if (HasFatalFailure()) return;
 
-  CollectionBackend::Album album = backend_->GetAlbumArt("Artist", "Album");
+  CollectionBackend::Album album = backend_->GetAlbumArt(QStringLiteral("Artist"), QStringLiteral("Album"));
   EXPECT_EQ(song_.album(), album.album);
   EXPECT_EQ(song_.effective_albumartist(), album.album_artist);
 
@@ -220,7 +220,7 @@ TEST_F(SingleSong, GetSongs) {
   AddDummySong();
   if (HasFatalFailure()) return;
 
-  SongList songs = backend_->GetAlbumSongs("Artist", "Album");
+  SongList songs = backend_->GetAlbumSongs(QStringLiteral("Artist"), QStringLiteral("Album"));
   ASSERT_EQ(1, songs.size());
   EXPECT_EQ(song_.album(), songs[0].album());
   EXPECT_EQ(song_.artist(), songs[0].artist());
@@ -263,7 +263,7 @@ TEST_F(SingleSong, UpdateSong) {
 
   Song new_song(song_);
   new_song.set_id(1);
-  new_song.set_title("A different title");
+  new_song.set_title(QStringLiteral("A different title"));
 
   QSignalSpy deleted_spy(&*backend_, &CollectionBackend::SongsDeleted);
   QSignalSpy added_spy(&*backend_, &CollectionBackend::SongsDiscovered);
@@ -277,8 +277,8 @@ TEST_F(SingleSong, UpdateSong) {
   SongList songs_deleted = *(reinterpret_cast<SongList*>(deleted_spy[0][0].data()));
   ASSERT_EQ(1, songs_added.size());
   ASSERT_EQ(1, songs_deleted.size());
-  EXPECT_EQ("Title", songs_deleted[0].title());
-  EXPECT_EQ("A different title", songs_added[0].title());
+  EXPECT_EQ(QStringLiteral("Title"), songs_deleted[0].title());
+  EXPECT_EQ(QStringLiteral("A different title"), songs_added[0].title());
   EXPECT_EQ(1, songs_deleted[0].id());
   EXPECT_EQ(1, songs_added[0].id());
 
@@ -300,7 +300,7 @@ TEST_F(SingleSong, DeleteSongs) {
 
   SongList songs_deleted = *(reinterpret_cast<SongList*>(deleted_spy[0][0].data()));
   ASSERT_EQ(1, songs_deleted.size());
-  EXPECT_EQ("Title", songs_deleted[0].title());
+  EXPECT_EQ(QStringLiteral("Title"), songs_deleted[0].title());
   EXPECT_EQ(1, songs_deleted[0].id());
 
   // Check we can't retrieve that song any more
@@ -333,7 +333,7 @@ TEST_F(SingleSong, MarkSongsUnavailable) {
 
   SongList songs_deleted = *(reinterpret_cast<SongList*>(deleted_spy[0][0].data()));
   ASSERT_EQ(1, songs_deleted.size());
-  EXPECT_EQ("Title", songs_deleted[0].title());
+  EXPECT_EQ(QStringLiteral("Title"), songs_deleted[0].title());
   EXPECT_EQ(1, songs_deleted[0].id());
 
   // Check the song is marked as deleted.
@@ -354,16 +354,16 @@ class TestUrls : public CollectionBackendTest {
  protected:
   void SetUp() override {
     CollectionBackendTest::SetUp();
-    backend_->AddDirectory("/mnt/music");
+    backend_->AddDirectory(QStringLiteral("/mnt/music"));
   }
 };
 
 TEST_F(TestUrls, TestUrls) {
 
-  QStringList strings = QStringList() << "file:///mnt/music/01 - Pink Floyd - Echoes.flac"
-                                      << "file:///mnt/music/02 - Björn Afzelius - Det räcker nu.flac"
-                                      << "file:///mnt/music/03 - Vazelina Bilopphøggers - Bomull i øra.flac"
-                                      << "file:///mnt/music/Test !#$%&'()-@^_`{}~..flac";
+  QStringList strings = QStringList() << QStringLiteral("file:///mnt/music/01 - Pink Floyd - Echoes.flac")
+                                      << QStringLiteral("file:///mnt/music/02 - Björn Afzelius - Det räcker nu.flac")
+                                      << QStringLiteral("file:///mnt/music/03 - Vazelina Bilopphøggers - Bomull i øra.flac")
+                                      << QStringLiteral("file:///mnt/music/Test !#$%&'()-@^_`{}~..flac");
 
   QList<QUrl> urls = QUrl::fromStringList(strings);
   SongList songs;
@@ -371,13 +371,13 @@ TEST_F(TestUrls, TestUrls) {
   for (const QUrl &url : urls) {
 
     EXPECT_EQ(url, QUrl::fromEncoded(url.toString(QUrl::FullyEncoded).toUtf8()));
-    EXPECT_EQ(url.toString(QUrl::FullyEncoded), url.toEncoded());
+    EXPECT_EQ(url.toString(QUrl::FullyEncoded), QString::fromLatin1(url.toEncoded()));
 
     Song song(Song::Source::Collection);
     song.set_directory_id(1);
-    song.set_title("Test Title");
-    song.set_album("Test Album");
-    song.set_artist("Test Artist");
+    song.set_title(QStringLiteral("Test Title"));
+    song.set_album(QStringLiteral("Test Album"));
+    song.set_artist(QStringLiteral("Test Artist"));
     song.set_url(url);
     song.set_length_nanosec(kNsecPerSec);
     song.set_mtime(1);
@@ -417,9 +417,9 @@ TEST_F(TestUrls, TestUrls) {
 
     QSqlDatabase db(database_->Connect());
     QSqlQuery q(db);
-    q.prepare(QString("SELECT url FROM %1 WHERE url = :url").arg(SCollection::kSongsTable));
+    q.prepare(QStringLiteral("SELECT url FROM %1 WHERE url = :url").arg(QLatin1String(SCollection::kSongsTable)));
 
-    q.bindValue(":url", url.toString(QUrl::FullyEncoded));
+    q.bindValue(QStringLiteral(":url"), url.toString(QUrl::FullyEncoded));
     EXPECT_TRUE(q.exec());
 
     while (q.next()) {
@@ -435,18 +435,18 @@ class UpdateSongsBySongID : public CollectionBackendTest {
  protected:
   void SetUp() override {
     CollectionBackendTest::SetUp();
-    backend_->AddDirectory("/mnt/music");
+    backend_->AddDirectory(QStringLiteral("/mnt/music"));
   }
 };
 
 TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
 
-    QStringList song_ids = QStringList() << "song1"
-                                         << "song2"
-                                         << "song3"
-                                         << "song4"
-                                         << "song5"
-                                         << "song6";
+    QStringList song_ids = QStringList() << QStringLiteral("song1")
+                                         << QStringLiteral("song2")
+                                         << QStringLiteral("song3")
+                                         << QStringLiteral("song4")
+                                         << QStringLiteral("song5")
+                                         << QStringLiteral("song6");
 
   { // Add songs
     SongMap songs;
@@ -454,15 +454,15 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
     for (const QString &song_id : song_ids) {
 
       QUrl url;
-      url.setScheme("file");
-      url.setPath("/music/" + song_id);
+      url.setScheme(QStringLiteral("file"));
+      url.setPath(QStringLiteral("/music/") + song_id);
 
       Song song(Song::Source::Collection);
       song.set_song_id(song_id);
       song.set_directory_id(1);
-      song.set_title("Test Title " + song_id);
-      song.set_album("Test Album");
-      song.set_artist("Test Artist");
+      song.set_title(QStringLiteral("Test Title ") + song_id);
+      song.set_album(QStringLiteral("Test Album"));
+      song.set_artist(QStringLiteral("Test Artist"));
       song.set_url(url);
       song.set_length_nanosec(kNsecPerSec);
       song.set_mtime(1);
@@ -495,7 +495,7 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
     SongMap songs;
     {
       QSqlDatabase db(database_->Connect());
-      CollectionQuery query(db, SCollection::kSongsTable, SCollection::kFtsTable);
+      CollectionQuery query(db, QLatin1String(SCollection::kSongsTable), QLatin1String(SCollection::kFtsTable));
       EXPECT_TRUE(backend_->ExecCollectionQuery(&query, songs));
     }
 
@@ -517,23 +517,23 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
 
     SongMap songs;
 
-    QStringList song_ids2 = QStringList() << "song1"
-                                          << "song4"
-                                          << "song5"
-                                          << "song6";
+    QStringList song_ids2 = QStringList() << QStringLiteral("song1")
+                                          << QStringLiteral("song4")
+                                          << QStringLiteral("song5")
+                                          << QStringLiteral("song6");
 
     for (const QString &song_id : song_ids2) {
 
       QUrl url;
-      url.setScheme("file");
-      url.setPath("/music/" + song_id);
+      url.setScheme(QStringLiteral("file"));
+      url.setPath(QStringLiteral("/music/") + song_id);
 
       Song song(Song::Source::Collection);
       song.set_song_id(song_id);
       song.set_directory_id(1);
-      song.set_title("Test Title " + song_id);
-      song.set_album("Test Album");
-      song.set_artist("Test Artist");
+      song.set_title(QStringLiteral("Test Title ") + song_id);
+      song.set_album(QStringLiteral("Test Album"));
+      song.set_artist(QStringLiteral("Test Artist"));
       song.set_url(url);
       song.set_length_nanosec(kNsecPerSec);
       song.set_mtime(1);
@@ -551,8 +551,8 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
     ASSERT_EQ(1, spy2.count());
     SongList deleted_songs = spy2[0][0].value<SongList>();
     EXPECT_EQ(deleted_songs.count(), 2);
-    EXPECT_EQ(deleted_songs[0].song_id(), "song2");
-    EXPECT_EQ(deleted_songs[1].song_id(), "song3");
+    EXPECT_EQ(deleted_songs[0].song_id(), QStringLiteral("song2"));
+    EXPECT_EQ(deleted_songs[1].song_id(), QStringLiteral("song3"));
 
   }
 
@@ -562,23 +562,23 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
 
     SongMap songs;
 
-    QStringList song_ids2 = QStringList() << "song1"
-                                          << "song4"
-                                          << "song5"
-                                          << "song6";
+    QStringList song_ids2 = QStringList() << QStringLiteral("song1")
+                                          << QStringLiteral("song4")
+                                          << QStringLiteral("song5")
+                                          << QStringLiteral("song6");
 
     for (const QString &song_id : song_ids2) {
 
       QUrl url;
-      url.setScheme("file");
-      url.setPath("/music/" + song_id);
+      url.setScheme(QStringLiteral("file"));
+      url.setPath(QStringLiteral("/music/") + song_id);
 
       Song song(Song::Source::Collection);
       song.set_song_id(song_id);
       song.set_directory_id(1);
-      song.set_title("Test Title " + song_id);
-      song.set_album("Test Album");
-      song.set_artist("Test Artist");
+      song.set_title(QStringLiteral("Test Title ") + song_id);
+      song.set_album(QStringLiteral("Test Album"));
+      song.set_artist(QStringLiteral("Test Artist"));
       song.set_url(url);
       song.set_length_nanosec(kNsecPerSec);
       song.set_mtime(1);
@@ -590,8 +590,8 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
 
     }
 
-    songs["song1"].set_artist("New artist");
-    songs["song6"].set_artist("New artist");
+    songs[QStringLiteral("song1")].set_artist(QStringLiteral("New artist"));
+    songs[QStringLiteral("song6")].set_artist(QStringLiteral("New artist"));
 
     backend_->UpdateSongsBySongID(songs);
 
@@ -601,10 +601,10 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
     SongList added_songs = spy2[0][0].value<SongList>();
     EXPECT_EQ(deleted_songs.count(), 2);
     EXPECT_EQ(added_songs.count(), 2);
-    EXPECT_EQ(deleted_songs[0].song_id(), "song1");
-    EXPECT_EQ(deleted_songs[1].song_id(), "song6");
-    EXPECT_EQ(added_songs[0].song_id(), "song1");
-    EXPECT_EQ(added_songs[1].song_id(), "song6");
+    EXPECT_EQ(deleted_songs[0].song_id(), QStringLiteral("song1"));
+    EXPECT_EQ(deleted_songs[1].song_id(), QStringLiteral("song6"));
+    EXPECT_EQ(added_songs[0].song_id(), QStringLiteral("song1"));
+    EXPECT_EQ(added_songs[1].song_id(), QStringLiteral("song6"));
 
   }
 
diff --git a/tests/src/collectionmodel_test.cpp b/tests/src/collectionmodel_test.cpp
index fd89b1b8..6897fa6d 100644
--- a/tests/src/collectionmodel_test.cpp
+++ b/tests/src/collectionmodel_test.cpp
@@ -54,7 +54,7 @@ class CollectionModelTest : public ::testing::Test {
   void SetUp() override {
     database_ = make_shared<MemoryDatabase>(nullptr);
     backend_ = make_shared<CollectionBackend>();
-    backend_->Init(database_, nullptr, Song::Source::Collection, SCollection::kSongsTable, SCollection::kFtsTable, SCollection::kDirsTable, SCollection::kSubdirsTable);
+    backend_->Init(database_, nullptr, Song::Source::Collection, QLatin1String(SCollection::kSongsTable), QLatin1String(SCollection::kFtsTable), QLatin1String(SCollection::kDirsTable), QLatin1String(SCollection::kSubdirsTable));
     model_ = make_unique<CollectionModel>(backend_, nullptr);
 
     added_dir_ = false;
@@ -71,11 +71,11 @@ class CollectionModelTest : public ::testing::Test {
     song.set_directory_id(1);
     if (song.mtime() == 0) song.set_mtime(1);
     if (song.ctime() == 0) song.set_ctime(1);
-    if (song.url().isEmpty()) song.set_url(QUrl("file:///tmp/foo"));
+    if (song.url().isEmpty()) song.set_url(QUrl(QStringLiteral("file:///tmp/foo")));
     if (song.filesize() == -1) song.set_filesize(1);
 
     if (!added_dir_) {
-      backend_->AddDirectory("/tmp");
+      backend_->AddDirectory(QStringLiteral("/tmp"));
       added_dir_ = true;
     }
 
@@ -105,24 +105,24 @@ TEST_F(CollectionModelTest, Initialization) {
 
 TEST_F(CollectionModelTest, WithInitialArtists) {
 
-  AddSong("Title", "Artist 1", "Album", 123);
-  AddSong("Title", "Artist 2", "Album", 123);
-  AddSong("Title", "Foo", "Album", 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("Artist 1"), QStringLiteral("Album"), 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("Artist 2"), QStringLiteral("Album"), 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("Foo"), QStringLiteral("Album"), 123);
   model_->Init(false);
 
   ASSERT_EQ(5, model_sorted_->rowCount(QModelIndex()));
-  EXPECT_EQ("A", model_sorted_->index(0, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("Artist 1", model_sorted_->index(1, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("Artist 2", model_sorted_->index(2, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("F", model_sorted_->index(3, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("Foo", model_sorted_->index(4, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("A"), model_sorted_->index(0, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("Artist 1"), model_sorted_->index(1, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("Artist 2"), model_sorted_->index(2, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("F"), model_sorted_->index(3, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("Foo"), model_sorted_->index(4, 0, QModelIndex()).data().toString());
 
 }
 
 TEST_F(CollectionModelTest, CompilationAlbums) {
 
   Song song;
-  song.Init("Title", "Artist", "Album", 123);
+  song.Init(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral("Album"), 123);
   song.set_compilation(true);
   song.set_mtime(0);
   song.set_ctime(0);
@@ -134,66 +134,66 @@ TEST_F(CollectionModelTest, CompilationAlbums) {
   ASSERT_EQ(1, model_->rowCount(QModelIndex()));
 
   QModelIndex va_index = model_->index(0, 0, QModelIndex());
-  EXPECT_EQ("Various artists", va_index.data().toString());
+  EXPECT_EQ(QStringLiteral("Various artists"), va_index.data().toString());
   EXPECT_TRUE(model_->hasChildren(va_index));
   ASSERT_EQ(model_->rowCount(va_index), 1);
 
   QModelIndex album_index = model_->index(0, 0, va_index);
-  EXPECT_EQ(model_->data(album_index).toString(), "Album");
+  EXPECT_EQ(model_->data(album_index).toString(), QStringLiteral("Album"));
   EXPECT_TRUE(model_->hasChildren(album_index));
 
 }
 
 TEST_F(CollectionModelTest, NumericHeaders) {
 
-  AddSong("Title", "1artist", "Album", 123);
-  AddSong("Title", "2artist", "Album", 123);
-  AddSong("Title", "0artist", "Album", 123);
-  AddSong("Title", "zartist", "Album", 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("1artist"), QStringLiteral("Album"), 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("2artist"), QStringLiteral("Album"), 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("0artist"), QStringLiteral("Album"), 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("zartist"), QStringLiteral("Album"), 123);
   model_->Init(false);
 
   ASSERT_EQ(6, model_sorted_->rowCount(QModelIndex()));
-  EXPECT_EQ("0-9", model_sorted_->index(0, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("0artist", model_sorted_->index(1, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("1artist", model_sorted_->index(2, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("2artist", model_sorted_->index(3, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("Z", model_sorted_->index(4, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("zartist", model_sorted_->index(5, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("0-9"), model_sorted_->index(0, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("0artist"), model_sorted_->index(1, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("1artist"), model_sorted_->index(2, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("2artist"), model_sorted_->index(3, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("Z"), model_sorted_->index(4, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("zartist"), model_sorted_->index(5, 0, QModelIndex()).data().toString());
 
 }
 
 TEST_F(CollectionModelTest, MixedCaseHeaders) {
 
-  AddSong("Title", "Artist", "Album", 123);
-  AddSong("Title", "artist", "Album", 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral("Album"), 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("artist"), QStringLiteral("Album"), 123);
   model_->Init(false);
 
   ASSERT_EQ(3, model_sorted_->rowCount(QModelIndex()));
-  EXPECT_EQ("A", model_sorted_->index(0, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("Artist", model_sorted_->index(1, 0, QModelIndex()).data().toString());
-  EXPECT_EQ("artist", model_sorted_->index(2, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("A"), model_sorted_->index(0, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("Artist"), model_sorted_->index(1, 0, QModelIndex()).data().toString());
+  EXPECT_EQ(QStringLiteral("artist"), model_sorted_->index(2, 0, QModelIndex()).data().toString());
 
 }
 
 TEST_F(CollectionModelTest, UnknownArtists) {
 
-  AddSong("Title", "", "Album", 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral(""), QStringLiteral("Album"), 123);
   model_->Init(false);
   model_->fetchMore(model_->index(0, 0));
 
   ASSERT_EQ(1, model_->rowCount(QModelIndex()));
   QModelIndex unknown_index = model_->index(0, 0, QModelIndex());
-  EXPECT_EQ("Unknown", unknown_index.data().toString());
+  EXPECT_EQ(QStringLiteral("Unknown"), unknown_index.data().toString());
 
   ASSERT_EQ(1, model_->rowCount(unknown_index));
-  EXPECT_EQ("Album", model_->index(0, 0, unknown_index).data().toString());
+  EXPECT_EQ(QStringLiteral("Album"), model_->index(0, 0, unknown_index).data().toString());
 
 }
 
 TEST_F(CollectionModelTest, UnknownAlbums) {
 
-  AddSong("Title", "Artist", "", 123);
-  AddSong("Title", "Artist", "Album", 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral(""), 123);
+  AddSong(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral("Album"), 123);
   model_->Init(false);
   model_->fetchMore(model_->index(0, 0));
 
@@ -203,8 +203,8 @@ TEST_F(CollectionModelTest, UnknownAlbums) {
   QModelIndex unknown_album_index = model_->index(0, 0, artist_index);
   QModelIndex real_album_index = model_->index(1, 0, artist_index);
 
-  EXPECT_EQ("Unknown", unknown_album_index.data().toString());
-  EXPECT_EQ("Album", real_album_index.data().toString());
+  EXPECT_EQ(QStringLiteral("Unknown"), unknown_album_index.data().toString());
+  EXPECT_EQ(QStringLiteral("Album"), real_album_index.data().toString());
 
 }
 
@@ -214,7 +214,7 @@ TEST_F(CollectionModelTest, VariousArtistSongs) {
   for (int i=0 ; i < 4 ; ++i) {
     QString n = QString::number(i+1);
     Song song;
-    song.Init("Title " + n, "Artist " + n, "Album", 0);
+    song.Init(QStringLiteral("Title ") + n, QStringLiteral("Artist ") + n, QStringLiteral("Album"), 0);
     song.set_mtime(0);
     song.set_ctime(0);
     songs << song;  // clazy:exclude=reserve-candidates
@@ -224,7 +224,7 @@ TEST_F(CollectionModelTest, VariousArtistSongs) {
   songs[0].set_compilation_detected(true);
   songs[1].set_compilation(true);
   songs[2].set_compilation_on(true);
-  songs[3].set_compilation_detected(true); songs[3].set_artist("Various Artists");
+  songs[3].set_compilation_detected(true); songs[3].set_artist(QStringLiteral("Various Artists"));
 
   for (int i=0 ; i < 4 ; ++i)
     AddSong(songs[i]);
@@ -238,18 +238,18 @@ TEST_F(CollectionModelTest, VariousArtistSongs) {
   model_->fetchMore(album_index);
   ASSERT_EQ(4, model_->rowCount(album_index));
 
-  EXPECT_EQ("Artist 1 - Title 1", model_->index(0, 0, album_index).data().toString());
-  EXPECT_EQ("Artist 2 - Title 2", model_->index(1, 0, album_index).data().toString());
-  EXPECT_EQ("Artist 3 - Title 3", model_->index(2, 0, album_index).data().toString());
-  EXPECT_EQ("Title 4", model_->index(3, 0, album_index).data().toString());
+  EXPECT_EQ(QStringLiteral("Artist 1 - Title 1"), model_->index(0, 0, album_index).data().toString());
+  EXPECT_EQ(QStringLiteral("Artist 2 - Title 2"), model_->index(1, 0, album_index).data().toString());
+  EXPECT_EQ(QStringLiteral("Artist 3 - Title 3"), model_->index(2, 0, album_index).data().toString());
+  EXPECT_EQ(QStringLiteral("Title 4"), model_->index(3, 0, album_index).data().toString());
 
 }
 
 TEST_F(CollectionModelTest, RemoveSongsLazyLoaded) {
 
-  Song one = AddSong("Title 1", "Artist", "Album", 123); one.set_id(1);
-  Song two = AddSong("Title 2", "Artist", "Album", 123); two.set_id(2);
-  AddSong("Title 3", "Artist", "Album", 123);
+  Song one = AddSong(QStringLiteral("Title 1"), QStringLiteral("Artist"), QStringLiteral("Album"), 123); one.set_id(1);
+  Song two = AddSong(QStringLiteral("Title 2"), QStringLiteral("Artist"), QStringLiteral("Album"), 123); two.set_id(2);
+  AddSong(QStringLiteral("Title 3"), QStringLiteral("Artist"), QStringLiteral("Album"), 123);
   model_->Init(false);
 
   // Lazy load the items
@@ -275,14 +275,14 @@ TEST_F(CollectionModelTest, RemoveSongsLazyLoaded) {
   ASSERT_EQ(1, model_->rowCount(artist_index));
   album_index = model_->index(0, 0, artist_index);
   ASSERT_EQ(1, model_->rowCount(album_index));
-  EXPECT_EQ("Title 3", model_->index(0, 0, album_index).data().toString());
+  EXPECT_EQ(QStringLiteral("Title 3"), model_->index(0, 0, album_index).data().toString());
 
 }
 
 TEST_F(CollectionModelTest, RemoveSongsNotLazyLoaded) {
 
-  Song one = AddSong("Title 1", "Artist", "Album", 123); one.set_id(1);
-  Song two = AddSong("Title 2", "Artist", "Album", 123); two.set_id(2);
+  Song one = AddSong(QStringLiteral("Title 1"), QStringLiteral("Artist"), QStringLiteral("Album"), 123); one.set_id(1);
+  Song two = AddSong(QStringLiteral("Title 2"), QStringLiteral("Artist"), QStringLiteral("Album"), 123); two.set_id(2);
   model_->Init(false);
 
   // Remove the first two songs
@@ -300,9 +300,9 @@ TEST_F(CollectionModelTest, RemoveSongsNotLazyLoaded) {
 
 TEST_F(CollectionModelTest, RemoveEmptyAlbums) {
 
-  Song one = AddSong("Title 1", "Artist", "Album 1", 123); one.set_id(1);
-  Song two = AddSong("Title 2", "Artist", "Album 2", 123); two.set_id(2);
-  Song three = AddSong("Title 3", "Artist", "Album 2", 123); three.set_id(3);
+  Song one = AddSong(QStringLiteral("Title 1"), QStringLiteral("Artist"), QStringLiteral("Album 1"), 123); one.set_id(1);
+  Song two = AddSong(QStringLiteral("Title 2"), QStringLiteral("Artist"), QStringLiteral("Album 2"), 123); two.set_id(2);
+  Song three = AddSong(QStringLiteral("Title 3"), QStringLiteral("Artist"), QStringLiteral("Album 2"), 123); three.set_id(3);
   model_->Init(false);
 
   QModelIndex artist_index = model_->index(0, 0, QModelIndex());
@@ -318,16 +318,16 @@ TEST_F(CollectionModelTest, RemoveEmptyAlbums) {
   ASSERT_EQ(1, model_->rowCount(artist_index));
   QModelIndex album_index = model_->index(0, 0, artist_index);
   model_->fetchMore(album_index);
-  EXPECT_EQ("Album 2", album_index.data().toString());
+  EXPECT_EQ(QStringLiteral("Album 2"), album_index.data().toString());
 
   ASSERT_EQ(1, model_->rowCount(album_index));
-  EXPECT_EQ("Title 3", model_->index(0, 0, album_index).data().toString());
+  EXPECT_EQ(QStringLiteral("Title 3"), model_->index(0, 0, album_index).data().toString());
 
 }
 
 TEST_F(CollectionModelTest, RemoveEmptyArtists) {
 
-  Song one = AddSong("Title", "Artist", "Album", 123); one.set_id(1);
+  Song one = AddSong(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral("Album"), 123); one.set_id(1);
   model_->Init(false);
 
   // Lazy load the items
diff --git a/tests/src/logging_env.h b/tests/src/logging_env.h
index 7669509f..504fd77c 100644
--- a/tests/src/logging_env.h
+++ b/tests/src/logging_env.h
@@ -30,7 +30,7 @@ class LoggingEnvironment : public ::testing::Environment {
   LoggingEnvironment() = default;
   void SetUp() override {
     logging::Init();
-    logging::SetLevels("*:4");
+    logging::SetLevels(QStringLiteral("*:4"));
   }
  private:
   Q_DISABLE_COPY(LoggingEnvironment)
diff --git a/tests/src/mergedproxymodel_test.cpp b/tests/src/mergedproxymodel_test.cpp
index b5329449..91d35c19 100644
--- a/tests/src/mergedproxymodel_test.cpp
+++ b/tests/src/mergedproxymodel_test.cpp
@@ -41,15 +41,15 @@ class MergedProxyModelTest : public ::testing::Test {
 
 TEST_F(MergedProxyModelTest, Flat) {
 
-  source_.appendRow(new QStandardItem("one"));
-  source_.appendRow(new QStandardItem("two"));
+  source_.appendRow(new QStandardItem(QStringLiteral("one")));
+  source_.appendRow(new QStandardItem(QStringLiteral("two")));
 
   ASSERT_EQ(2, merged_.rowCount(QModelIndex()));
   QModelIndex one_i = merged_.index(0, 0, QModelIndex());
   QModelIndex two_i = merged_.index(1, 0, QModelIndex());
 
-  EXPECT_EQ("one", one_i.data().toString());
-  EXPECT_EQ("two", two_i.data().toString());
+  EXPECT_EQ(QStringLiteral("one"), one_i.data().toString());
+  EXPECT_EQ(QStringLiteral("two"), two_i.data().toString());
   EXPECT_FALSE(merged_.parent(one_i).isValid());
   EXPECT_FALSE(merged_.hasChildren(one_i));
 
@@ -57,8 +57,8 @@ TEST_F(MergedProxyModelTest, Flat) {
 
 TEST_F(MergedProxyModelTest, Tree) {
 
-  QStandardItem* one = new QStandardItem("one");
-  QStandardItem* two = new QStandardItem("two");
+  QStandardItem* one = new QStandardItem(QStringLiteral("one"));
+  QStandardItem* two = new QStandardItem(QStringLiteral("two"));
   source_.appendRow(one);
   one->appendRow(two);
 
@@ -68,31 +68,31 @@ TEST_F(MergedProxyModelTest, Tree) {
   ASSERT_EQ(1, merged_.rowCount(one_i));
   QModelIndex two_i = merged_.index(0, 0, one_i);
 
-  EXPECT_EQ("one", one_i.data().toString());
-  EXPECT_EQ("two", two_i.data().toString());
-  EXPECT_EQ("one", two_i.parent().data().toString());
+  EXPECT_EQ(QStringLiteral("one"), one_i.data().toString());
+  EXPECT_EQ(QStringLiteral("two"), two_i.data().toString());
+  EXPECT_EQ(QStringLiteral("one"), two_i.parent().data().toString());
 
 }
 
 TEST_F(MergedProxyModelTest, Merged) {
 
-  source_.appendRow(new QStandardItem("one"));
+  source_.appendRow(new QStandardItem(QStringLiteral("one")));
 
   QStandardItemModel submodel;
-  submodel.appendRow(new QStandardItem("two"));
+  submodel.appendRow(new QStandardItem(QStringLiteral("two")));
 
   merged_.AddSubModel(source_.index(0, 0, QModelIndex()), &submodel);
 
   ASSERT_EQ(1, merged_.rowCount(QModelIndex()));
   QModelIndex one_i = merged_.index(0, 0, QModelIndex());
 
-  EXPECT_EQ("one", merged_.data(one_i).toString());
+  EXPECT_EQ(QStringLiteral("one"), merged_.data(one_i).toString());
   EXPECT_TRUE(merged_.hasChildren(one_i));
 
   ASSERT_EQ(1, merged_.rowCount(one_i));
   QModelIndex two_i = merged_.index(0, 0, one_i);
 
-  EXPECT_EQ("two", merged_.data(two_i).toString());
+  EXPECT_EQ(QStringLiteral("two"), merged_.data(two_i).toString());
   EXPECT_EQ(0, merged_.rowCount(two_i));
   EXPECT_FALSE(merged_.hasChildren(two_i));
 
@@ -103,7 +103,7 @@ TEST_F(MergedProxyModelTest, SourceInsert) {
   QSignalSpy before_spy(&merged_, &MergedProxyModel::rowsAboutToBeInserted);
   QSignalSpy after_spy(&merged_, &MergedProxyModel::rowsInserted);
 
-  source_.appendRow(new QStandardItem("one"));
+  source_.appendRow(new QStandardItem(QStringLiteral("one")));
 
   ASSERT_EQ(1, before_spy.count());
   ASSERT_EQ(1, after_spy.count());
@@ -118,7 +118,7 @@ TEST_F(MergedProxyModelTest, SourceInsert) {
 
 TEST_F(MergedProxyModelTest, SourceRemove) {
 
-  source_.appendRow(new QStandardItem("one"));
+  source_.appendRow(new QStandardItem(QStringLiteral("one")));
 
   QSignalSpy before_spy(&merged_, &MergedProxyModel::rowsAboutToBeRemoved);
   QSignalSpy after_spy(&merged_, &MergedProxyModel::rowsRemoved);
@@ -138,21 +138,21 @@ TEST_F(MergedProxyModelTest, SourceRemove) {
 
 TEST_F(MergedProxyModelTest, SubInsert) {
 
-  source_.appendRow(new QStandardItem("one"));
+  source_.appendRow(new QStandardItem(QStringLiteral("one")));
   QStandardItemModel submodel;
   merged_.AddSubModel(source_.index(0, 0, QModelIndex()), &submodel);
 
   QSignalSpy before_spy(&merged_, &MergedProxyModel::rowsAboutToBeInserted);
   QSignalSpy after_spy(&merged_, &MergedProxyModel::rowsInserted);
 
-  submodel.appendRow(new QStandardItem("two"));
+  submodel.appendRow(new QStandardItem(QStringLiteral("two")));
 
   ASSERT_EQ(1, before_spy.count());
   ASSERT_EQ(1, after_spy.count());
-  EXPECT_EQ("one", before_spy[0][0].toModelIndex().data());
+  EXPECT_EQ(QStringLiteral("one"), before_spy[0][0].toModelIndex().data());
   EXPECT_EQ(0, before_spy[0][1].toInt());
   EXPECT_EQ(0, before_spy[0][2].toInt());
-  EXPECT_EQ("one", after_spy[0][0].toModelIndex().data());
+  EXPECT_EQ(QStringLiteral("one"), after_spy[0][0].toModelIndex().data());
   EXPECT_EQ(0, after_spy[0][1].toInt());
   EXPECT_EQ(0, after_spy[0][2].toInt());
 
@@ -160,11 +160,11 @@ TEST_F(MergedProxyModelTest, SubInsert) {
 
 TEST_F(MergedProxyModelTest, SubRemove) {
 
-  source_.appendRow(new QStandardItem("one"));
+  source_.appendRow(new QStandardItem(QStringLiteral("one")));
   QStandardItemModel submodel;
   merged_.AddSubModel(source_.index(0, 0, QModelIndex()), &submodel);
 
-  submodel.appendRow(new QStandardItem("two"));
+  submodel.appendRow(new QStandardItem(QStringLiteral("two")));
 
   QSignalSpy before_spy(&merged_, &MergedProxyModel::rowsAboutToBeRemoved);
   QSignalSpy after_spy(&merged_, &MergedProxyModel::rowsRemoved);
@@ -173,10 +173,10 @@ TEST_F(MergedProxyModelTest, SubRemove) {
 
   ASSERT_EQ(1, before_spy.count());
   ASSERT_EQ(1, after_spy.count());
-  EXPECT_EQ("one", before_spy[0][0].toModelIndex().data());
+  EXPECT_EQ(QStringLiteral("one"), before_spy[0][0].toModelIndex().data());
   EXPECT_EQ(0, before_spy[0][1].toInt());
   EXPECT_EQ(0, before_spy[0][2].toInt());
-  EXPECT_EQ("one", after_spy[0][0].toModelIndex().data());
+  EXPECT_EQ(QStringLiteral("one"), after_spy[0][0].toModelIndex().data());
   EXPECT_EQ(0, after_spy[0][1].toInt());
   EXPECT_EQ(0, after_spy[0][2].toInt());
 
diff --git a/tests/src/organizeformat_test.cpp b/tests/src/organizeformat_test.cpp
index 7d0b14f1..a87fb4d3 100644
--- a/tests/src/organizeformat_test.cpp
+++ b/tests/src/organizeformat_test.cpp
@@ -40,124 +40,124 @@ protected:
 
 TEST_F(OrganizeFormatTest, BasicReplace) {
 
-  song_.set_title("title");
-  song_.set_album("album");
-  song_.set_artist("artist");
-  song_.set_albumartist("albumartist");
+  song_.set_title(QStringLiteral("title"));
+  song_.set_album(QStringLiteral("album"));
+  song_.set_artist(QStringLiteral("artist"));
+  song_.set_albumartist(QStringLiteral("albumartist"));
   song_.set_track(321);
   song_.set_disc(789);
   song_.set_year(2010);
   song_.set_originalyear(1995);
-  song_.set_genre("genre");
-  song_.set_composer("composer");
-  song_.set_performer("performer");
-  song_.set_grouping("grouping");
-  song_.set_comment("comment");
+  song_.set_genre(QStringLiteral("genre"));
+  song_.set_composer(QStringLiteral("composer"));
+  song_.set_performer(QStringLiteral("performer"));
+  song_.set_grouping(QStringLiteral("grouping"));
+  song_.set_comment(QStringLiteral("comment"));
   song_.set_length_nanosec(987 * kNsecPerSec);
   song_.set_samplerate(654);
   song_.set_bitdepth(32);
   song_.set_bitrate(123);
 
-  format_.set_format("%album %albumartist %artist %bitrate %comment %composer %performer %grouping %disc %genre %length %samplerate %bitdepth %title %track %year");
+  format_.set_format(QStringLiteral("%album %albumartist %artist %bitrate %comment %composer %performer %grouping %disc %genre %length %samplerate %bitdepth %title %track %year"));
 
   ASSERT_TRUE(format_.IsValid());
 
-  EXPECT_EQ("album_albumartist_artist_123_comment_composer_performer_grouping_789_genre_987_654_32_title_321_2010", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("album_albumartist_artist_123_comment_composer_performer_grouping_789_genre_987_654_32_title_321_2010"), format_.GetFilenameForSong(song_).filename);
 
 }
 
 TEST_F(OrganizeFormatTest, BasicReplacePaths) {
 
-  song_.set_title("title");
-  song_.set_album("album");
-  song_.set_artist("artist");
-  song_.set_albumartist("albumartist");
+  song_.set_title(QStringLiteral("title"));
+  song_.set_album(QStringLiteral("album"));
+  song_.set_artist(QStringLiteral("artist"));
+  song_.set_albumartist(QStringLiteral("albumartist"));
   song_.set_track(321);
 
-  format_.set_format("%albumartist/%album/%track %albumartist %artist %album %title");
+  format_.set_format(QStringLiteral("%albumartist/%album/%track %albumartist %artist %album %title"));
 
   ASSERT_TRUE(format_.IsValid());
 
-  EXPECT_EQ("albumartist/album/321_albumartist_artist_album_title", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("albumartist/album/321_albumartist_artist_album_title"), format_.GetFilenameForSong(song_).filename);
 
 }
 
 TEST_F(OrganizeFormatTest, ArtistInitial) {
 
-  song_.set_artist("bob");
+  song_.set_artist(QStringLiteral("bob"));
 
-  format_.set_format("%artistinitial");
+  format_.set_format(QStringLiteral("%artistinitial"));
   ASSERT_TRUE(format_.IsValid());
-  EXPECT_EQ("B", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("B"), format_.GetFilenameForSong(song_).filename);
 
 }
 
 TEST_F(OrganizeFormatTest, AlbumArtistInitial) {
 
-  song_.set_albumartist("bob");
+  song_.set_albumartist(QStringLiteral("bob"));
 
-  format_.set_format("%artistinitial");
+  format_.set_format(QStringLiteral("%artistinitial"));
   ASSERT_TRUE(format_.IsValid());
-  EXPECT_EQ("B", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("B"), format_.GetFilenameForSong(song_).filename);
 
 }
 
 TEST_F(OrganizeFormatTest, InvalidTag) {
 
-  format_.set_format("%invalid");
+  format_.set_format(QStringLiteral("%invalid"));
   EXPECT_FALSE(format_.IsValid());
 
 }
 
 TEST_F(OrganizeFormatTest, Blocks) {
 
-  format_.set_format("Before{Inside%year}After");
+  format_.set_format(QStringLiteral("Before{Inside%year}After"));
   ASSERT_TRUE(format_.IsValid());
 
   song_.set_year(-1);
-  EXPECT_EQ("BeforeAfter", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("BeforeAfter"), format_.GetFilenameForSong(song_).filename);
 
   song_.set_year(0);
-  EXPECT_EQ("BeforeAfter", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("BeforeAfter"), format_.GetFilenameForSong(song_).filename);
 
   song_.set_year(123);
-  EXPECT_EQ("BeforeInside123After", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("BeforeInside123After"), format_.GetFilenameForSong(song_).filename);
 
 }
 
 TEST_F(OrganizeFormatTest, ReplaceSpaces) {
 
-  song_.set_title("The Song Title");
-  format_.set_format("The Format String %title");
+  song_.set_title(QStringLiteral("The Song Title"));
+  format_.set_format(QStringLiteral("The Format String %title"));
 
   format_.set_replace_spaces(false);
-  EXPECT_EQ("The Format String The Song Title", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("The Format String The Song Title"), format_.GetFilenameForSong(song_).filename);
   format_.set_replace_spaces(true);
-  EXPECT_EQ("The_Format_String_The_Song_Title", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("The_Format_String_The_Song_Title"), format_.GetFilenameForSong(song_).filename);
 
 }
 
 TEST_F(OrganizeFormatTest, ReplaceNonAscii) {
 
-  song_.set_artist(QString::fromUtf8("Röyksopp"));
-  format_.set_format("%artist");
+  song_.set_artist(QStringLiteral("Röyksopp"));
+  format_.set_format(QStringLiteral("%artist"));
 
   format_.set_remove_non_ascii(false);
-  EXPECT_EQ(QString::fromUtf8("Röyksopp"), format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("Röyksopp"), format_.GetFilenameForSong(song_).filename);
 
   format_.set_remove_non_ascii(true);
-  EXPECT_EQ("Royksopp", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("Royksopp"), format_.GetFilenameForSong(song_).filename);
 
-  song_.set_artist("");
-  EXPECT_EQ("", format_.GetFilenameForSong(song_).filename);
+  song_.set_artist(QLatin1String(""));
+  EXPECT_EQ(QLatin1String(""), format_.GetFilenameForSong(song_).filename);
 
 #ifdef HAVE_ICU
 
-  song_.set_artist(QString::fromUtf8("Владимир Высоцкий"));
-  EXPECT_EQ("Vladimir_Vysockij", format_.GetFilenameForSong(song_).filename);
+  song_.set_artist(QStringLiteral("Владимир Высоцкий"));
+  EXPECT_EQ(QStringLiteral("Vladimir_Vysockij"), format_.GetFilenameForSong(song_).filename);
 
-  song_.set_artist(QString::fromUtf8("エックス・ジャパン"));
-  EXPECT_EQ("ekkusujapan", format_.GetFilenameForSong(song_).filename);
+  song_.set_artist(QStringLiteral("エックス・ジャパン"));
+  EXPECT_EQ(QStringLiteral("ekkusujapan"), format_.GetFilenameForSong(song_).filename);
 
 #endif
 
@@ -165,26 +165,26 @@ TEST_F(OrganizeFormatTest, ReplaceNonAscii) {
 
 TEST_F(OrganizeFormatTest, TrackNumberPadding) {
 
-  format_.set_format("%track");
+  format_.set_format(QStringLiteral("%track"));
 
   song_.set_track(9);
-  EXPECT_EQ("09", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("09"), format_.GetFilenameForSong(song_).filename);
 
   song_.set_track(99);
-  EXPECT_EQ("99", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("99"), format_.GetFilenameForSong(song_).filename);
 
   song_.set_track(999);
-  EXPECT_EQ("999", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QStringLiteral("999"), format_.GetFilenameForSong(song_).filename);
 
   song_.set_track(0);
-  EXPECT_EQ("", format_.GetFilenameForSong(song_).filename);
+  EXPECT_EQ(QLatin1String(""), format_.GetFilenameForSong(song_).filename);
 
 }
 
 TEST_F(OrganizeFormatTest, ReplaceSlashes) {
 
-  format_.set_format("%title");
-  song_.set_title("foo/bar\\baz");
-  EXPECT_EQ("foobarbaz", format_.GetFilenameForSong(song_).filename);
+  format_.set_format(QStringLiteral("%title"));
+  song_.set_title(QStringLiteral("foo/bar\\baz"));
+  EXPECT_EQ(QStringLiteral("foobarbaz"), format_.GetFilenameForSong(song_).filename);
 
 }
diff --git a/tests/src/playlist_test.cpp b/tests/src/playlist_test.cpp
index ee1111be..4d62adf4 100644
--- a/tests/src/playlist_test.cpp
+++ b/tests/src/playlist_test.cpp
@@ -76,7 +76,7 @@ TEST_F(PlaylistTest, Basic) {
 
 TEST_F(PlaylistTest, InsertItems) {
 
-  MockPlaylistItem* item = MakeMockItem("Title", "Artist", "Album", 123);
+  MockPlaylistItem *item = MakeMockItem(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral("Album"), 123);
   PlaylistItemPtr item_ptr(item);
 
   // Insert the item
@@ -85,22 +85,22 @@ TEST_F(PlaylistTest, InsertItems) {
   ASSERT_EQ(1, playlist_.rowCount(QModelIndex()));
 
   // Get the metadata
-  EXPECT_EQ("Title", playlist_.data(playlist_.index(0, Playlist::Column_Title)));
-  EXPECT_EQ("Artist", playlist_.data(playlist_.index(0, Playlist::Column_Artist)));
-  EXPECT_EQ("Album", playlist_.data(playlist_.index(0, Playlist::Column_Album)));
+  EXPECT_EQ(QStringLiteral("Title"), playlist_.data(playlist_.index(0, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Artist"), playlist_.data(playlist_.index(0, Playlist::Column_Artist)));
+  EXPECT_EQ(QStringLiteral("Album"), playlist_.data(playlist_.index(0, Playlist::Column_Album)));
   EXPECT_EQ(123, playlist_.data(playlist_.index(0, Playlist::Column_Length)));
 
 }
 
 TEST_F(PlaylistTest, Indexes) {
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   // Start "playing" track 1
   playlist_.set_current_row(0);
   EXPECT_EQ(0, playlist_.current_row());
-  EXPECT_EQ("One", playlist_.current_item()->Metadata().title());
+  EXPECT_EQ(QStringLiteral("One"), playlist_.current_item()->Metadata().title());
   EXPECT_EQ(-1, playlist_.previous_row());
   EXPECT_EQ(1, playlist_.next_row());
 
@@ -113,14 +113,14 @@ TEST_F(PlaylistTest, Indexes) {
   // Play track 2
   playlist_.set_current_row(1);
   EXPECT_EQ(1, playlist_.current_row());
-  EXPECT_EQ("Two", playlist_.current_item()->Metadata().title());
+  EXPECT_EQ(QStringLiteral("Two"), playlist_.current_item()->Metadata().title());
   EXPECT_EQ(0, playlist_.previous_row());
   EXPECT_EQ(2, playlist_.next_row());
 
   // Play track 3
   playlist_.set_current_row(2);
   EXPECT_EQ(2, playlist_.current_row());
-  EXPECT_EQ("Three", playlist_.current_item()->Metadata().title());
+  EXPECT_EQ(QStringLiteral("Three"), playlist_.current_item()->Metadata().title());
   EXPECT_EQ(1, playlist_.previous_row());
   EXPECT_EQ(-1, playlist_.next_row());
 
@@ -128,7 +128,7 @@ TEST_F(PlaylistTest, Indexes) {
 
 TEST_F(PlaylistTest, RepeatPlaylist) {
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   playlist_.sequence()->SetRepeatMode(PlaylistSequence::RepeatMode::Playlist);
@@ -146,7 +146,7 @@ TEST_F(PlaylistTest, RepeatPlaylist) {
 
 TEST_F(PlaylistTest, RepeatTrack) {
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   playlist_.sequence()->SetRepeatMode(PlaylistSequence::RepeatMode::Track);
@@ -159,9 +159,9 @@ TEST_F(PlaylistTest, RepeatTrack) {
 TEST_F(PlaylistTest, RepeatAlbum) {
 
   playlist_.InsertItems(PlaylistItemPtrList()
-      << MakeMockItemP("One", "Album one")
-      << MakeMockItemP("Two", "Album two")
-      << MakeMockItemP("Three", "Album one"));
+      << MakeMockItemP(QStringLiteral("One"), QStringLiteral("Album one"))
+      << MakeMockItemP(QStringLiteral("Two"), QStringLiteral("Album two"))
+      << MakeMockItemP(QStringLiteral("Three"), QStringLiteral("Album one")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   playlist_.sequence()->SetRepeatMode(PlaylistSequence::RepeatMode::Album);
@@ -177,7 +177,7 @@ TEST_F(PlaylistTest, RepeatAlbum) {
 TEST_F(PlaylistTest, RemoveBeforeCurrent) {
 
   playlist_.InsertItems(PlaylistItemPtrList()
-      << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+      << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   // Remove a row before the currently playing track
@@ -194,7 +194,7 @@ TEST_F(PlaylistTest, RemoveBeforeCurrent) {
 TEST_F(PlaylistTest, RemoveAfterCurrent) {
 
   playlist_.InsertItems(PlaylistItemPtrList()
-      << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+      << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   // Remove a row after the currently playing track
@@ -213,7 +213,7 @@ TEST_F(PlaylistTest, RemoveAfterCurrent) {
 
 TEST_F(PlaylistTest, RemoveCurrent) {
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   // Remove the currently playing track's row
@@ -229,12 +229,12 @@ TEST_F(PlaylistTest, RemoveCurrent) {
 
 TEST_F(PlaylistTest, InsertBeforeCurrent) {
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   playlist_.set_current_row(1);
   EXPECT_EQ(1, playlist_.current_row());
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Four"), 0);
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Four")), 0);
   ASSERT_EQ(4, playlist_.rowCount(QModelIndex()));
 
   EXPECT_EQ(2, playlist_.current_row());
@@ -242,19 +242,19 @@ TEST_F(PlaylistTest, InsertBeforeCurrent) {
   EXPECT_EQ(1, playlist_.previous_row());
   EXPECT_EQ(3, playlist_.next_row());
 
-  EXPECT_EQ("Four", playlist_.data(playlist_.index(0, Playlist::Column_Title)));
-  EXPECT_EQ("One", playlist_.data(playlist_.index(1, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Four"), playlist_.data(playlist_.index(0, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("One"), playlist_.data(playlist_.index(1, Playlist::Column_Title)));
 
 }
 
 TEST_F(PlaylistTest, InsertAfterCurrent) {
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   playlist_.set_current_row(1);
   EXPECT_EQ(1, playlist_.current_row());
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Four"), 2);
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Four")), 2);
   ASSERT_EQ(4, playlist_.rowCount(QModelIndex()));
 
   EXPECT_EQ(1, playlist_.current_row());
@@ -262,15 +262,15 @@ TEST_F(PlaylistTest, InsertAfterCurrent) {
   EXPECT_EQ(0, playlist_.previous_row());
   EXPECT_EQ(2, playlist_.next_row());
 
-  EXPECT_EQ("Two", playlist_.data(playlist_.index(1, Playlist::Column_Title)));
-  EXPECT_EQ("Four", playlist_.data(playlist_.index(2, Playlist::Column_Title)));
-  EXPECT_EQ("Three", playlist_.data(playlist_.index(3, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Two"), playlist_.data(playlist_.index(1, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Four"), playlist_.data(playlist_.index(2, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Three"), playlist_.data(playlist_.index(3, Playlist::Column_Title)));
 
 }
 
 TEST_F(PlaylistTest, Clear) {
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   playlist_.set_current_row(1);
@@ -290,7 +290,7 @@ TEST_F(PlaylistTest, UndoAdd) {
   EXPECT_FALSE(playlist_.undo_stack()->canUndo());
   EXPECT_FALSE(playlist_.undo_stack()->canRedo());
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Title"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Title")));
   EXPECT_EQ(1, playlist_.rowCount(QModelIndex()));
   EXPECT_FALSE(playlist_.undo_stack()->canRedo());
   ASSERT_TRUE(playlist_.undo_stack()->canUndo());
@@ -305,26 +305,26 @@ TEST_F(PlaylistTest, UndoAdd) {
   EXPECT_FALSE(playlist_.undo_stack()->canRedo());
   EXPECT_TRUE(playlist_.undo_stack()->canUndo());
 
-  EXPECT_EQ("Title", playlist_.data(playlist_.index(0, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Title"), playlist_.data(playlist_.index(0, Playlist::Column_Title)));
 
 }
 
 TEST_F(PlaylistTest, UndoMultiAdd) {
 
   // Add 1 item
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")));
 
   // Add 2 items
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Two") << MakeMockItemP("Three"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
 
   // Undo adding 2 items
   ASSERT_TRUE(playlist_.undo_stack()->canUndo());
-  EXPECT_EQ("add 2 songs", playlist_.undo_stack()->undoText());
+  EXPECT_EQ(QStringLiteral("add 2 songs"), playlist_.undo_stack()->undoText());
   playlist_.undo_stack()->undo();
 
   // Undo adding 1 item
   ASSERT_TRUE(playlist_.undo_stack()->canUndo());
-  EXPECT_EQ("add 1 songs", playlist_.undo_stack()->undoText());
+  EXPECT_EQ(QStringLiteral("add 1 songs"), playlist_.undo_stack()->undoText());
   playlist_.undo_stack()->undo();
 
   EXPECT_FALSE(playlist_.undo_stack()->canUndo());
@@ -336,7 +336,7 @@ TEST_F(PlaylistTest, UndoRemove) {
   EXPECT_FALSE(playlist_.undo_stack()->canUndo());
   EXPECT_FALSE(playlist_.undo_stack()->canRedo());
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Title"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Title")));
 
   EXPECT_TRUE(playlist_.undo_stack()->canUndo());
   EXPECT_FALSE(playlist_.undo_stack()->canRedo());
@@ -351,7 +351,7 @@ TEST_F(PlaylistTest, UndoRemove) {
   EXPECT_EQ(1, playlist_.rowCount(QModelIndex()));
   ASSERT_TRUE(playlist_.undo_stack()->canRedo());
 
-  EXPECT_EQ("Title", playlist_.data(playlist_.index(0, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Title"), playlist_.data(playlist_.index(0, Playlist::Column_Title)));
 
   playlist_.undo_stack()->redo();
   EXPECT_EQ(0, playlist_.rowCount(QModelIndex()));
@@ -363,7 +363,7 @@ TEST_F(PlaylistTest, UndoRemove) {
 TEST_F(PlaylistTest, UndoMultiRemove) {
 
   // Add 3 items
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   // Remove 1 item
@@ -376,7 +376,7 @@ TEST_F(PlaylistTest, UndoMultiRemove) {
 
   // Undo removing all 3 items
   ASSERT_TRUE(playlist_.undo_stack()->canUndo());
-  EXPECT_EQ("remove 3 songs", playlist_.undo_stack()->undoText());
+  EXPECT_EQ(QStringLiteral("remove 3 songs"), playlist_.undo_stack()->undoText());
 
   playlist_.undo_stack()->undo();
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
@@ -385,13 +385,13 @@ TEST_F(PlaylistTest, UndoMultiRemove) {
 
 TEST_F(PlaylistTest, UndoClear) {
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
 
   playlist_.Clear();
   ASSERT_EQ(0, playlist_.rowCount(QModelIndex()));
   ASSERT_TRUE(playlist_.undo_stack()->canUndo());
-  EXPECT_EQ("remove 3 songs", playlist_.undo_stack()->undoText());
+  EXPECT_EQ(QStringLiteral("remove 3 songs"), playlist_.undo_stack()->undoText());
   playlist_.undo_stack()->undo();
 
   ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
@@ -400,7 +400,7 @@ TEST_F(PlaylistTest, UndoClear) {
 
 TEST_F(PlaylistTest, UndoRemoveCurrent) {
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Title"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Title")));
   playlist_.set_current_row(0);
   EXPECT_EQ(0, playlist_.current_row());
   EXPECT_EQ(0, playlist_.last_played_row());
@@ -417,7 +417,7 @@ TEST_F(PlaylistTest, UndoRemoveCurrent) {
 
 TEST_F(PlaylistTest, UndoRemoveOldCurrent) {
 
-  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Title"));
+  playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Title")));
   playlist_.set_current_row(0);
   EXPECT_EQ(0, playlist_.current_row());
   EXPECT_EQ(0, playlist_.last_played_row());
@@ -440,7 +440,7 @@ TEST_F(PlaylistTest, ShuffleThenNext) {
   PlaylistItemPtrList items;
   items.reserve(100);
   for (int i=0 ; i<100 ; ++i)
-    items << MakeMockItemP("Item " + QString::number(i));
+    items << MakeMockItemP(QStringLiteral("Item ") + QString::number(i));
   playlist_.InsertItems(items);
 
   playlist_.set_current_row(0);
@@ -453,8 +453,8 @@ TEST_F(PlaylistTest, ShuffleThenNext) {
   }
 
   int index = playlist_.current_row();
-  EXPECT_EQ("Item 0", playlist_.current_item()->Metadata().title());
-  EXPECT_EQ("Item 0", playlist_.data(playlist_.index(index, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Item 0"), playlist_.current_item()->Metadata().title());
+  EXPECT_EQ(QStringLiteral("Item 0"), playlist_.data(playlist_.index(index, Playlist::Column_Title)));
   EXPECT_EQ(index, playlist_.last_played_row());
   //EXPECT_EQ(index + 1, playlist_.next_row());
 
@@ -466,8 +466,8 @@ TEST_F(PlaylistTest, ShuffleThenNext) {
   //}
 
   index = playlist_.current_row();
-  EXPECT_EQ("Item 0", playlist_.current_item()->Metadata().title());
-  EXPECT_EQ("Item 0", playlist_.data(playlist_.index(index, Playlist::Column_Title)));
+  EXPECT_EQ(QStringLiteral("Item 0"), playlist_.current_item()->Metadata().title());
+  EXPECT_EQ(QStringLiteral("Item 0"), playlist_.data(playlist_.index(index, Playlist::Column_Title)));
   EXPECT_EQ(index, playlist_.last_played_row());
   //EXPECT_EQ(-1, playlist_.next_row());
   //EXPECT_EQ(index-1, playlist_.previous_row());
@@ -477,7 +477,7 @@ TEST_F(PlaylistTest, ShuffleThenNext) {
 TEST_F(PlaylistTest, CollectionIdMapSingle) {
 
   Song song;
-  song.Init("title", "artist", "album", 123);
+  song.Init(QStringLiteral("title"), QStringLiteral("artist"), QStringLiteral("album"), 123);
   song.set_id(1);
 
   PlaylistItemPtr item(std::make_shared<CollectionPlaylistItem>(song));
@@ -498,7 +498,7 @@ TEST_F(PlaylistTest, CollectionIdMapSingle) {
 TEST_F(PlaylistTest, CollectionIdMapInvalid) {
 
   Song invalid;
-  invalid.Init("title", "artist", "album", 123);
+  invalid.Init(QStringLiteral("title"), QStringLiteral("artist"), QStringLiteral("album"), 123);
   ASSERT_EQ(-1, invalid.id());
 
   PlaylistItemPtr item(std::make_shared<CollectionPlaylistItem>(invalid));
@@ -514,11 +514,11 @@ TEST_F(PlaylistTest, CollectionIdMapInvalid) {
 TEST_F(PlaylistTest, CollectionIdMapMulti) {
 
   Song one;
-  one.Init("title", "artist", "album", 123);
+  one.Init(QStringLiteral("title"), QStringLiteral("artist"), QStringLiteral("album"), 123);
   one.set_id(1);
 
   Song two;
-  two.Init("title 2", "artist 2", "album 2", 123);
+  two.Init(QStringLiteral("title 2"), QStringLiteral("artist 2"), QStringLiteral("album 2"), 123);
   two.set_id(2);
 
   PlaylistItemPtr item_one(std::make_shared<CollectionPlaylistItem>(one));
diff --git a/tests/src/songplaylistitem_test.cpp b/tests/src/songplaylistitem_test.cpp
index 68a6fd54..7ec37ca4 100644
--- a/tests/src/songplaylistitem_test.cpp
+++ b/tests/src/songplaylistitem_test.cpp
@@ -41,7 +41,7 @@ namespace {
 
 class SongPlaylistItemTest : public ::testing::TestWithParam<const char*> {
  protected:
-  SongPlaylistItemTest() : temp_file_(GetParam()) {}
+  SongPlaylistItemTest() : temp_file_(QString::fromUtf8(GetParam())) {}
 
   void SetUp() override {
     // SongPlaylistItem::Url() checks if the file exists, so we need a real file
@@ -49,13 +49,13 @@ class SongPlaylistItemTest : public ::testing::TestWithParam<const char*> {
 
     absolute_file_name_ = QFileInfo(temp_file_.fileName()).absoluteFilePath();
 
-    song_.Init("Title", "Artist", "Album", 123);
+    song_.Init(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral("Album"), 123);
     song_.set_url(QUrl::fromLocalFile(absolute_file_name_));
 
     item_ = make_unique<SongPlaylistItem>(song_);
 
-    if (!absolute_file_name_.startsWith('/'))
-      absolute_file_name_.prepend('/');
+    if (!absolute_file_name_.startsWith(QLatin1Char('/')))
+      absolute_file_name_.prepend(QLatin1Char('/'));
   }
 
   Song song_;  // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes)
@@ -73,7 +73,7 @@ INSTANTIATE_TEST_SUITE_P(RealFiles, SongPlaylistItemTest, testing::Values(  // c
 
 TEST_P(SongPlaylistItemTest, Url) {
   QUrl expected;
-  expected.setScheme("file");
+  expected.setScheme(QStringLiteral("file"));
   expected.setPath(absolute_file_name_);
 
   EXPECT_EQ(expected, item_->Url());
diff --git a/tests/src/tagreader_test.cpp b/tests/src/tagreader_test.cpp
index a6c68c69..532984da 100644
--- a/tests/src/tagreader_test.cpp
+++ b/tests/src/tagreader_test.cpp
@@ -92,7 +92,7 @@ class TagReaderTest : public ::testing::Test {
         hash.addData(buffer);
       }
       file.close();
-      return hash.result().toHex();
+      return QString::fromLatin1(hash.result().toHex());
     }
     return QString();
   }
@@ -123,7 +123,7 @@ class TagReaderTest : public ::testing::Test {
 
 TEST_F(TagReaderTest, TestFLACAudioFileTagging) {
 
-  TemporaryResource r(":/audio/strawberry.flac");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.flac"));
 
   QString sha256sum_notags = SHA256SUM(r.fileName());
   EXPECT_FALSE(sha256sum_notags.isEmpty());
@@ -132,7 +132,7 @@ TEST_F(TagReaderTest, TestFLACAudioFileTagging) {
     QByteArray orig_file_data;
     QByteArray temp_file_data;
     {
-      QFile orig_file(":/audio/strawberry.flac");
+      QFile orig_file(QStringLiteral(":/audio/strawberry.flac"));
       orig_file.open(QIODevice::ReadOnly);
       EXPECT_TRUE(orig_file.isOpen());
       orig_file_data = orig_file.readAll();
@@ -157,16 +157,16 @@ TEST_F(TagReaderTest, TestFLACAudioFileTagging) {
 
   {  // Write tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -179,16 +179,16 @@ TEST_F(TagReaderTest, TestFLACAudioFileTagging) {
 
   { // Read tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -197,16 +197,16 @@ TEST_F(TagReaderTest, TestFLACAudioFileTagging) {
 
   { // Write new tags
     Song song;
-    song.set_title("new title");
-    song.set_artist("new artist");
-    song.set_album("new album");
-    song.set_albumartist("new album artist");
-    song.set_composer("new composer");
-    song.set_performer("new performer");
-    song.set_grouping("new grouping");
-    song.set_genre("new genre");
-    song.set_comment("new comment");
-    song.set_lyrics("new lyrics");
+    song.set_title(QStringLiteral("new title"));
+    song.set_artist(QStringLiteral("new artist"));
+    song.set_album(QStringLiteral("new album"));
+    song.set_albumartist(QStringLiteral("new album artist"));
+    song.set_composer(QStringLiteral("new composer"));
+    song.set_performer(QStringLiteral("new performer"));
+    song.set_grouping(QStringLiteral("new grouping"));
+    song.set_genre(QStringLiteral("new genre"));
+    song.set_comment(QStringLiteral("new comment"));
+    song.set_lyrics(QStringLiteral("new lyrics"));
     song.set_track(21);
     song.set_disc(4321);
     song.set_year(9102);
@@ -215,16 +215,16 @@ TEST_F(TagReaderTest, TestFLACAudioFileTagging) {
 
   { // Read new tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("new title", song.title());
-    EXPECT_EQ("new artist", song.artist());
-    EXPECT_EQ("new album", song.album());
-    EXPECT_EQ("new album artist", song.albumartist());
-    EXPECT_EQ("new composer", song.composer());
-    EXPECT_EQ("new performer", song.performer());
-    EXPECT_EQ("new grouping", song.grouping());
-    EXPECT_EQ("new genre", song.genre());
-    EXPECT_EQ("new comment", song.comment());
-    EXPECT_EQ("new lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("new title"), song.title());
+    EXPECT_EQ(QStringLiteral("new artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("new album"), song.album());
+    EXPECT_EQ(QStringLiteral("new album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("new composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("new performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("new grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("new genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("new comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("new lyrics"), song.lyrics());
     EXPECT_EQ(21, song.track());
     EXPECT_EQ(4321, song.disc());
     EXPECT_EQ(9102, song.year());
@@ -232,16 +232,16 @@ TEST_F(TagReaderTest, TestFLACAudioFileTagging) {
 
   { // Write original tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -250,16 +250,16 @@ TEST_F(TagReaderTest, TestFLACAudioFileTagging) {
 
   { // Read original tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -283,7 +283,7 @@ TEST_F(TagReaderTest, TestFLACAudioFileTagging) {
 
 TEST_F(TagReaderTest, TestWavPackAudioFileTagging) {
 
-  TemporaryResource r(":/audio/strawberry.wv");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.wv"));
 
   QString sha256sum_notags = SHA256SUM(r.fileName());
   EXPECT_FALSE(sha256sum_notags.isEmpty());
@@ -292,7 +292,7 @@ TEST_F(TagReaderTest, TestWavPackAudioFileTagging) {
     QByteArray orig_file_data;
     QByteArray temp_file_data;
     {
-      QFile orig_file(":/audio/strawberry.wv");
+      QFile orig_file(QStringLiteral(":/audio/strawberry.wv"));
       orig_file.open(QIODevice::ReadOnly);
       EXPECT_TRUE(orig_file.isOpen());
       orig_file_data = orig_file.readAll();
@@ -317,16 +317,16 @@ TEST_F(TagReaderTest, TestWavPackAudioFileTagging) {
 
   { // Write tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -339,16 +339,16 @@ TEST_F(TagReaderTest, TestWavPackAudioFileTagging) {
 
   { // Read tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -356,16 +356,16 @@ TEST_F(TagReaderTest, TestWavPackAudioFileTagging) {
 
   { // Write new tags
     Song song;
-    song.set_title("new title");
-    song.set_artist("new artist");
-    song.set_album("new album");
-    song.set_albumartist("new album artist");
-    song.set_composer("new composer");
-    song.set_performer("new performer");
-    song.set_grouping("new grouping");
-    song.set_genre("new genre");
-    song.set_comment("new comment");
-    song.set_lyrics("new lyrics");
+    song.set_title(QStringLiteral("new title"));
+    song.set_artist(QStringLiteral("new artist"));
+    song.set_album(QStringLiteral("new album"));
+    song.set_albumartist(QStringLiteral("new album artist"));
+    song.set_composer(QStringLiteral("new composer"));
+    song.set_performer(QStringLiteral("new performer"));
+    song.set_grouping(QStringLiteral("new grouping"));
+    song.set_genre(QStringLiteral("new genre"));
+    song.set_comment(QStringLiteral("new comment"));
+    song.set_lyrics(QStringLiteral("new lyrics"));
     song.set_track(21);
     song.set_disc(4321);
     song.set_year(9102);
@@ -374,16 +374,16 @@ TEST_F(TagReaderTest, TestWavPackAudioFileTagging) {
 
   { // Read new tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("new title", song.title());
-    EXPECT_EQ("new artist", song.artist());
-    EXPECT_EQ("new album", song.album());
-    EXPECT_EQ("new album artist", song.albumartist());
-    EXPECT_EQ("new composer", song.composer());
-    EXPECT_EQ("new performer", song.performer());
-    EXPECT_EQ("new grouping", song.grouping());
-    EXPECT_EQ("new genre", song.genre());
-    EXPECT_EQ("new comment", song.comment());
-    EXPECT_EQ("new lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("new title"), song.title());
+    EXPECT_EQ(QStringLiteral("new artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("new album"), song.album());
+    EXPECT_EQ(QStringLiteral("new album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("new composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("new performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("new grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("new genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("new comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("new lyrics"), song.lyrics());
     EXPECT_EQ(21, song.track());
     EXPECT_EQ(4321, song.disc());
     EXPECT_EQ(9102, song.year());
@@ -391,16 +391,16 @@ TEST_F(TagReaderTest, TestWavPackAudioFileTagging) {
 
   { // Write original tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -409,16 +409,16 @@ TEST_F(TagReaderTest, TestWavPackAudioFileTagging) {
 
   { // Read original tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -442,7 +442,7 @@ TEST_F(TagReaderTest, TestWavPackAudioFileTagging) {
 
 TEST_F(TagReaderTest, TestOggFLACAudioFileTagging) {
 
-  TemporaryResource r(":/audio/strawberry.oga");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.oga"));
 
   QString sha256sum_notags = SHA256SUM(r.fileName());
   EXPECT_FALSE(sha256sum_notags.isEmpty());
@@ -451,7 +451,7 @@ TEST_F(TagReaderTest, TestOggFLACAudioFileTagging) {
     QByteArray orig_file_data;
     QByteArray temp_file_data;
     {
-      QFile orig_file(":/audio/strawberry.oga");
+      QFile orig_file(QStringLiteral(":/audio/strawberry.oga"));
       orig_file.open(QIODevice::ReadOnly);
       EXPECT_TRUE(orig_file.isOpen());
       orig_file_data = orig_file.readAll();
@@ -476,16 +476,16 @@ TEST_F(TagReaderTest, TestOggFLACAudioFileTagging) {
 
   { // Write tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -498,16 +498,16 @@ TEST_F(TagReaderTest, TestOggFLACAudioFileTagging) {
 
   { // Read tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -515,16 +515,16 @@ TEST_F(TagReaderTest, TestOggFLACAudioFileTagging) {
 
   { // Write new tags
     Song song;
-    song.set_title("new title");
-    song.set_artist("new artist");
-    song.set_album("new album");
-    song.set_albumartist("new album artist");
-    song.set_composer("new composer");
-    song.set_performer("new performer");
-    song.set_grouping("new grouping");
-    song.set_genre("new genre");
-    song.set_comment("new comment");
-    song.set_lyrics("new lyrics");
+    song.set_title(QStringLiteral("new title"));
+    song.set_artist(QStringLiteral("new artist"));
+    song.set_album(QStringLiteral("new album"));
+    song.set_albumartist(QStringLiteral("new album artist"));
+    song.set_composer(QStringLiteral("new composer"));
+    song.set_performer(QStringLiteral("new performer"));
+    song.set_grouping(QStringLiteral("new grouping"));
+    song.set_genre(QStringLiteral("new genre"));
+    song.set_comment(QStringLiteral("new comment"));
+    song.set_lyrics(QStringLiteral("new lyrics"));
     song.set_track(21);
     song.set_disc(4321);
     song.set_year(9102);
@@ -533,16 +533,16 @@ TEST_F(TagReaderTest, TestOggFLACAudioFileTagging) {
 
   {  // Read new tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("new title", song.title());
-    EXPECT_EQ("new artist", song.artist());
-    EXPECT_EQ("new album", song.album());
-    EXPECT_EQ("new album artist", song.albumartist());
-    EXPECT_EQ("new composer", song.composer());
-    EXPECT_EQ("new performer", song.performer());
-    EXPECT_EQ("new grouping", song.grouping());
-    EXPECT_EQ("new genre", song.genre());
-    EXPECT_EQ("new comment", song.comment());
-    EXPECT_EQ("new lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("new title"), song.title());
+    EXPECT_EQ(QStringLiteral("new artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("new album"), song.album());
+    EXPECT_EQ(QStringLiteral("new album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("new composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("new performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("new grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("new genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("new comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("new lyrics"), song.lyrics());
     EXPECT_EQ(21, song.track());
     EXPECT_EQ(4321, song.disc());
     EXPECT_EQ(9102, song.year());
@@ -550,16 +550,16 @@ TEST_F(TagReaderTest, TestOggFLACAudioFileTagging) {
 
   { // Write original tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -568,16 +568,16 @@ TEST_F(TagReaderTest, TestOggFLACAudioFileTagging) {
 
   { // Read original tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -601,7 +601,7 @@ TEST_F(TagReaderTest, TestOggFLACAudioFileTagging) {
 
 TEST_F(TagReaderTest, TestOggVorbisAudioFileTagging) {
 
-  TemporaryResource r(":/audio/strawberry.ogg");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.ogg"));
 
   QString sha256sum_notags = SHA256SUM(r.fileName());
   EXPECT_FALSE(sha256sum_notags.isEmpty());
@@ -610,7 +610,7 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFileTagging) {
     QByteArray orig_file_data;
     QByteArray temp_file_data;
     {
-      QFile orig_file(":/audio/strawberry.ogg");
+      QFile orig_file(QStringLiteral(":/audio/strawberry.ogg"));
       orig_file.open(QIODevice::ReadOnly);
       EXPECT_TRUE(orig_file.isOpen());
       orig_file_data = orig_file.readAll();
@@ -635,16 +635,16 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFileTagging) {
 
   { // Write tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -657,16 +657,16 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFileTagging) {
 
   { // Read tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -675,16 +675,16 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFileTagging) {
 
   { // Write new tags
     Song song;
-    song.set_title("new title");
-    song.set_artist("new artist");
-    song.set_album("new album");
-    song.set_albumartist("new album artist");
-    song.set_composer("new composer");
-    song.set_performer("new performer");
-    song.set_grouping("new grouping");
-    song.set_genre("new genre");
-    song.set_comment("new comment");
-    song.set_lyrics("new lyrics");
+    song.set_title(QStringLiteral("new title"));
+    song.set_artist(QStringLiteral("new artist"));
+    song.set_album(QStringLiteral("new album"));
+    song.set_albumartist(QStringLiteral("new album artist"));
+    song.set_composer(QStringLiteral("new composer"));
+    song.set_performer(QStringLiteral("new performer"));
+    song.set_grouping(QStringLiteral("new grouping"));
+    song.set_genre(QStringLiteral("new genre"));
+    song.set_comment(QStringLiteral("new comment"));
+    song.set_lyrics(QStringLiteral("new lyrics"));
     song.set_track(21);
     song.set_disc(4321);
     song.set_year(9102);
@@ -693,15 +693,15 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFileTagging) {
 
   { // Read new tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("new title", song.title());
-    EXPECT_EQ("new artist", song.artist());
-    EXPECT_EQ("new album", song.album());
-    EXPECT_EQ("new album artist", song.albumartist());
-    EXPECT_EQ("new composer", song.composer());
-    EXPECT_EQ("new performer", song.performer());
-    EXPECT_EQ("new grouping", song.grouping());
-    EXPECT_EQ("new genre", song.genre());
-    EXPECT_EQ("new comment", song.comment());
+    EXPECT_EQ(QStringLiteral("new title"), song.title());
+    EXPECT_EQ(QStringLiteral("new artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("new album"), song.album());
+    EXPECT_EQ(QStringLiteral("new album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("new composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("new performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("new grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("new genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("new comment"), song.comment());
     EXPECT_EQ(21, song.track());
     EXPECT_EQ(4321, song.disc());
     EXPECT_EQ(9102, song.year());
@@ -709,16 +709,16 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFileTagging) {
 
   { // Write original tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -727,16 +727,16 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFileTagging) {
 
   { // Read original tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -760,7 +760,7 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFileTagging) {
 
 TEST_F(TagReaderTest, TestOggOpusAudioFileTagging) {
 
-  TemporaryResource r(":/audio/strawberry.opus");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.opus"));
 
   QString sha256sum_notags = SHA256SUM(r.fileName());
   EXPECT_FALSE(sha256sum_notags.isEmpty());
@@ -769,7 +769,7 @@ TEST_F(TagReaderTest, TestOggOpusAudioFileTagging) {
     QByteArray orig_file_data;
     QByteArray temp_file_data;
     {
-      QFile orig_file(":/audio/strawberry.opus");
+      QFile orig_file(QStringLiteral(":/audio/strawberry.opus"));
       orig_file.open(QIODevice::ReadOnly);
       EXPECT_TRUE(orig_file.isOpen());
       orig_file_data = orig_file.readAll();
@@ -794,16 +794,16 @@ TEST_F(TagReaderTest, TestOggOpusAudioFileTagging) {
 
   { // Write tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -816,16 +816,16 @@ TEST_F(TagReaderTest, TestOggOpusAudioFileTagging) {
 
   { // Read tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -834,16 +834,16 @@ TEST_F(TagReaderTest, TestOggOpusAudioFileTagging) {
 
   { // Write new tags
     Song song;
-    song.set_title("new title");
-    song.set_artist("new artist");
-    song.set_album("new album");
-    song.set_albumartist("new album artist");
-    song.set_composer("new composer");
-    song.set_performer("new performer");
-    song.set_grouping("new grouping");
-    song.set_genre("new genre");
-    song.set_comment("new comment");
-    song.set_lyrics("new lyrics");
+    song.set_title(QStringLiteral("new title"));
+    song.set_artist(QStringLiteral("new artist"));
+    song.set_album(QStringLiteral("new album"));
+    song.set_albumartist(QStringLiteral("new album artist"));
+    song.set_composer(QStringLiteral("new composer"));
+    song.set_performer(QStringLiteral("new performer"));
+    song.set_grouping(QStringLiteral("new grouping"));
+    song.set_genre(QStringLiteral("new genre"));
+    song.set_comment(QStringLiteral("new comment"));
+    song.set_lyrics(QStringLiteral("new lyrics"));
     song.set_track(21);
     song.set_disc(4321);
     song.set_year(9102);
@@ -852,16 +852,16 @@ TEST_F(TagReaderTest, TestOggOpusAudioFileTagging) {
 
   { // Read new tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("new title", song.title());
-    EXPECT_EQ("new artist", song.artist());
-    EXPECT_EQ("new album", song.album());
-    EXPECT_EQ("new album artist", song.albumartist());
-    EXPECT_EQ("new composer", song.composer());
-    EXPECT_EQ("new performer", song.performer());
-    EXPECT_EQ("new grouping", song.grouping());
-    EXPECT_EQ("new genre", song.genre());
-    EXPECT_EQ("new comment", song.comment());
-    EXPECT_EQ("new lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("new title"), song.title());
+    EXPECT_EQ(QStringLiteral("new artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("new album"), song.album());
+    EXPECT_EQ(QStringLiteral("new album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("new composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("new performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("new grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("new genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("new comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("new lyrics"), song.lyrics());
     EXPECT_EQ(21, song.track());
     EXPECT_EQ(4321, song.disc());
     EXPECT_EQ(9102, song.year());
@@ -869,16 +869,16 @@ TEST_F(TagReaderTest, TestOggOpusAudioFileTagging) {
 
   { // Write original tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -887,16 +887,16 @@ TEST_F(TagReaderTest, TestOggOpusAudioFileTagging) {
 
   { // Read original tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -920,7 +920,7 @@ TEST_F(TagReaderTest, TestOggOpusAudioFileTagging) {
 
 TEST_F(TagReaderTest, TestOggSpeexAudioFileTagging) {
 
-  TemporaryResource r(":/audio/strawberry.spx");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.spx"));
 
   QString sha256sum_notags = SHA256SUM(r.fileName());
   EXPECT_FALSE(sha256sum_notags.isEmpty());
@@ -929,7 +929,7 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFileTagging) {
     QByteArray orig_file_data;
     QByteArray temp_file_data;
     {
-      QFile orig_file(":/audio/strawberry.spx");
+      QFile orig_file(QStringLiteral(":/audio/strawberry.spx"));
       orig_file.open(QIODevice::ReadOnly);
       EXPECT_TRUE(orig_file.isOpen());
       orig_file_data = orig_file.readAll();
@@ -954,16 +954,16 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFileTagging) {
 
   { // Write tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -976,16 +976,16 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFileTagging) {
 
   { // Read tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -994,16 +994,16 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFileTagging) {
 
   { // Write new tags
     Song song;
-    song.set_title("new title");
-    song.set_artist("new artist");
-    song.set_album("new album");
-    song.set_albumartist("new album artist");
-    song.set_composer("new composer");
-    song.set_performer("new performer");
-    song.set_grouping("new grouping");
-    song.set_genre("new genre");
-    song.set_comment("new comment");
-    song.set_lyrics("new lyrics");
+    song.set_title(QStringLiteral("new title"));
+    song.set_artist(QStringLiteral("new artist"));
+    song.set_album(QStringLiteral("new album"));
+    song.set_albumartist(QStringLiteral("new album artist"));
+    song.set_composer(QStringLiteral("new composer"));
+    song.set_performer(QStringLiteral("new performer"));
+    song.set_grouping(QStringLiteral("new grouping"));
+    song.set_genre(QStringLiteral("new genre"));
+    song.set_comment(QStringLiteral("new comment"));
+    song.set_lyrics(QStringLiteral("new lyrics"));
     song.set_track(21);
     song.set_disc(4321);
     song.set_year(9102);
@@ -1012,16 +1012,16 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFileTagging) {
 
   { // Read new tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("new title", song.title());
-    EXPECT_EQ("new artist", song.artist());
-    EXPECT_EQ("new album", song.album());
-    EXPECT_EQ("new album artist", song.albumartist());
-    EXPECT_EQ("new composer", song.composer());
-    EXPECT_EQ("new performer", song.performer());
-    EXPECT_EQ("new grouping", song.grouping());
-    EXPECT_EQ("new genre", song.genre());
-    EXPECT_EQ("new comment", song.comment());
-    EXPECT_EQ("new lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("new title"), song.title());
+    EXPECT_EQ(QStringLiteral("new artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("new album"), song.album());
+    EXPECT_EQ(QStringLiteral("new album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("new composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("new performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("new grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("new genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("new comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("new lyrics"), song.lyrics());
     EXPECT_EQ(21, song.track());
     EXPECT_EQ(4321, song.disc());
     EXPECT_EQ(9102, song.year());
@@ -1029,16 +1029,16 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFileTagging) {
 
   { // Write original tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -1047,16 +1047,16 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFileTagging) {
 
   { // Read original tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -1080,7 +1080,7 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFileTagging) {
 
 TEST_F(TagReaderTest, TestAIFFAudioFileTagging) {
 
-  TemporaryResource r(":/audio/strawberry.aif");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.aif"));
 
   QString sha256sum_notags = SHA256SUM(r.fileName());
   EXPECT_FALSE(sha256sum_notags.isEmpty());
@@ -1089,7 +1089,7 @@ TEST_F(TagReaderTest, TestAIFFAudioFileTagging) {
     QByteArray orig_file_data;
     QByteArray temp_file_data;
     {
-      QFile orig_file(":/audio/strawberry.aif");
+      QFile orig_file(QStringLiteral(":/audio/strawberry.aif"));
       orig_file.open(QIODevice::ReadOnly);
       EXPECT_TRUE(orig_file.isOpen());
       orig_file_data = orig_file.readAll();
@@ -1114,16 +1114,16 @@ TEST_F(TagReaderTest, TestAIFFAudioFileTagging) {
 
   { // Write tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -1136,16 +1136,16 @@ TEST_F(TagReaderTest, TestAIFFAudioFileTagging) {
 
   { // Read tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    //EXPECT_EQ("strawberry album artist", song.albumartist());
-    //EXPECT_EQ("strawberry composer", song.composer());
-    //EXPECT_EQ("strawberry performer", song.performer());
-    //EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    //EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    //EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    //EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    //EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    //EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    //EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     //EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -1153,16 +1153,16 @@ TEST_F(TagReaderTest, TestAIFFAudioFileTagging) {
 
   { // Write new tags
     Song song;
-    song.set_title("new title");
-    song.set_artist("new artist");
-    song.set_album("new album");
-    song.set_albumartist("new album artist");
-    song.set_composer("new composer");
-    song.set_performer("new performer");
-    song.set_grouping("new grouping");
-    song.set_genre("new genre");
-    song.set_comment("new comment");
-    song.set_lyrics("new lyrics");
+    song.set_title(QStringLiteral("new title"));
+    song.set_artist(QStringLiteral("new artist"));
+    song.set_album(QStringLiteral("new album"));
+    song.set_albumartist(QStringLiteral("new album artist"));
+    song.set_composer(QStringLiteral("new composer"));
+    song.set_performer(QStringLiteral("new performer"));
+    song.set_grouping(QStringLiteral("new grouping"));
+    song.set_genre(QStringLiteral("new genre"));
+    song.set_comment(QStringLiteral("new comment"));
+    song.set_lyrics(QStringLiteral("new lyrics"));
     song.set_track(21);
     song.set_disc(4321);
     song.set_year(9102);
@@ -1171,16 +1171,16 @@ TEST_F(TagReaderTest, TestAIFFAudioFileTagging) {
 
   { // Read new tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("new title", song.title());
-    EXPECT_EQ("new artist", song.artist());
-    EXPECT_EQ("new album", song.album());
-    //EXPECT_EQ("new album artist", song.albumartist());
-    //EXPECT_EQ("new composer", song.composer());
-    //EXPECT_EQ("new performer", song.performer());
-    //EXPECT_EQ("new grouping", song.grouping());
-    EXPECT_EQ("new genre", song.genre());
-    EXPECT_EQ("new comment", song.comment());
-    //EXPECT_EQ("new lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("new title"), song.title());
+    EXPECT_EQ(QStringLiteral("new artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("new album"), song.album());
+    //EXPECT_EQ(QStringLiteral("new album artist"), song.albumartist());
+    //EXPECT_EQ(QStringLiteral("new composer"), song.composer());
+    //EXPECT_EQ(QStringLiteral("new performer"), song.performer());
+    //EXPECT_EQ(QStringLiteral("new grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("new genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("new comment"), song.comment());
+    //EXPECT_EQ(QStringLiteral("new lyrics"), song.lyrics());
     EXPECT_EQ(21, song.track());
     //EXPECT_EQ(4321, song.disc());
     EXPECT_EQ(9102, song.year());
@@ -1188,16 +1188,16 @@ TEST_F(TagReaderTest, TestAIFFAudioFileTagging) {
 
   {  // Write original tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -1206,16 +1206,16 @@ TEST_F(TagReaderTest, TestAIFFAudioFileTagging) {
 
   {  // Read original tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    //EXPECT_EQ("strawberry album artist", song.albumartist());
-    //EXPECT_EQ("strawberry composer", song.composer());
-    //EXPECT_EQ("strawberry performer", song.performer());
-    //EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    //EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    //EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    //EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    //EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    //EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    //EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     //EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -1239,7 +1239,7 @@ TEST_F(TagReaderTest, TestAIFFAudioFileTagging) {
 
 TEST_F(TagReaderTest, TestASFAudioFileTagging) {
 
-  TemporaryResource r(":/audio/strawberry.asf");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.asf"));
 
   QString sha256sum_notags = SHA256SUM(r.fileName());
   EXPECT_FALSE(sha256sum_notags.isEmpty());
@@ -1248,7 +1248,7 @@ TEST_F(TagReaderTest, TestASFAudioFileTagging) {
     QByteArray orig_file_data;
     QByteArray temp_file_data;
     {
-      QFile orig_file(":/audio/strawberry.asf");
+      QFile orig_file(QStringLiteral(":/audio/strawberry.asf"));
       orig_file.open(QIODevice::ReadOnly);
       EXPECT_TRUE(orig_file.isOpen());
       orig_file_data = orig_file.readAll();
@@ -1273,16 +1273,16 @@ TEST_F(TagReaderTest, TestASFAudioFileTagging) {
 
   { // Write tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -1295,16 +1295,16 @@ TEST_F(TagReaderTest, TestASFAudioFileTagging) {
 
   { // Read tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    //EXPECT_EQ("strawberry album artist", song.albumartist());
-    //EXPECT_EQ("strawberry composer", song.composer());
-    //EXPECT_EQ("strawberry performer", song.performer());
-    //EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    //EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    //EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    //EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    //EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    //EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    //EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     //EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -1313,16 +1313,16 @@ TEST_F(TagReaderTest, TestASFAudioFileTagging) {
 
   { // Write new tags
     Song song;
-    song.set_title("new title");
-    song.set_artist("new artist");
-    song.set_album("new album");
-    song.set_albumartist("new album artist");
-    song.set_composer("new composer");
-    song.set_performer("new performer");
-    song.set_grouping("new grouping");
-    song.set_genre("new genre");
-    song.set_comment("new comment");
-    song.set_lyrics("new lyrics");
+    song.set_title(QStringLiteral("new title"));
+    song.set_artist(QStringLiteral("new artist"));
+    song.set_album(QStringLiteral("new album"));
+    song.set_albumartist(QStringLiteral("new album artist"));
+    song.set_composer(QStringLiteral("new composer"));
+    song.set_performer(QStringLiteral("new performer"));
+    song.set_grouping(QStringLiteral("new grouping"));
+    song.set_genre(QStringLiteral("new genre"));
+    song.set_comment(QStringLiteral("new comment"));
+    song.set_lyrics(QStringLiteral("new lyrics"));
     song.set_track(21);
     song.set_disc(4321);
     song.set_year(9102);
@@ -1331,16 +1331,16 @@ TEST_F(TagReaderTest, TestASFAudioFileTagging) {
 
   { // Read new tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("new title", song.title());
-    EXPECT_EQ("new artist", song.artist());
-    EXPECT_EQ("new album", song.album());
-    //EXPECT_EQ("new album artist", song.albumartist());
-    //EXPECT_EQ("new composer", song.composer());
-    //EXPECT_EQ("new performer", song.performer());
-    //EXPECT_EQ("new grouping", song.grouping());
-    EXPECT_EQ("new genre", song.genre());
-    EXPECT_EQ("new comment", song.comment());
-    //EXPECT_EQ("new lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("new title"), song.title());
+    EXPECT_EQ(QStringLiteral("new artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("new album"), song.album());
+    //EXPECT_EQ(QStringLiteral("new album artist"), song.albumartist());
+    //EXPECT_EQ(QStringLiteral("new composer"), song.composer());
+    //EXPECT_EQ(QStringLiteral("new performer"), song.performer());
+    //EXPECT_EQ(QStringLiteral("new grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("new genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("new comment"), song.comment());
+    //EXPECT_EQ(QStringLiteral("new lyrics"), song.lyrics());
     EXPECT_EQ(21, song.track());
     //EXPECT_EQ(4321, song.disc());
     EXPECT_EQ(9102, song.year());
@@ -1348,16 +1348,16 @@ TEST_F(TagReaderTest, TestASFAudioFileTagging) {
 
   { // Write original tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -1366,16 +1366,16 @@ TEST_F(TagReaderTest, TestASFAudioFileTagging) {
 
   { // Read original tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    //EXPECT_EQ("strawberry album artist", song.albumartist());
-    //EXPECT_EQ("strawberry composer", song.composer());
-    //EXPECT_EQ("strawberry performer", song.performer());
-    //EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    //EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    //EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    //EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    //EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    //EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    //EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     //EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -1399,7 +1399,7 @@ TEST_F(TagReaderTest, TestASFAudioFileTagging) {
 
 TEST_F(TagReaderTest, TestMP3AudioFileTagging) {
 
-  TemporaryResource r(":/audio/strawberry.mp3");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.mp3"));
 
   QString sha256sum_notags = SHA256SUM(r.fileName());
   EXPECT_FALSE(sha256sum_notags.isEmpty());
@@ -1408,7 +1408,7 @@ TEST_F(TagReaderTest, TestMP3AudioFileTagging) {
     QByteArray orig_file_data;
     QByteArray temp_file_data;
     {
-      QFile orig_file(":/audio/strawberry.mp3");
+      QFile orig_file(QStringLiteral(":/audio/strawberry.mp3"));
       orig_file.open(QIODevice::ReadOnly);
       EXPECT_TRUE(orig_file.isOpen());
       orig_file_data = orig_file.readAll();
@@ -1433,16 +1433,16 @@ TEST_F(TagReaderTest, TestMP3AudioFileTagging) {
 
   { // Write tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -1455,16 +1455,16 @@ TEST_F(TagReaderTest, TestMP3AudioFileTagging) {
 
   { // Read tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -1472,16 +1472,16 @@ TEST_F(TagReaderTest, TestMP3AudioFileTagging) {
 
   { // Write new tags
     Song song;
-    song.set_title("new title");
-    song.set_artist("new artist");
-    song.set_album("new album");
-    song.set_albumartist("new album artist");
-    song.set_composer("new composer");
-    song.set_performer("new performer");
-    song.set_grouping("new grouping");
-    song.set_genre("new genre");
-    song.set_comment("new comment");
-    song.set_lyrics("new lyrics");
+    song.set_title(QStringLiteral("new title"));
+    song.set_artist(QStringLiteral("new artist"));
+    song.set_album(QStringLiteral("new album"));
+    song.set_albumartist(QStringLiteral("new album artist"));
+    song.set_composer(QStringLiteral("new composer"));
+    song.set_performer(QStringLiteral("new performer"));
+    song.set_grouping(QStringLiteral("new grouping"));
+    song.set_genre(QStringLiteral("new genre"));
+    song.set_comment(QStringLiteral("new comment"));
+    song.set_lyrics(QStringLiteral("new lyrics"));
     song.set_track(21);
     song.set_disc(4321);
     song.set_year(9102);
@@ -1490,33 +1490,33 @@ TEST_F(TagReaderTest, TestMP3AudioFileTagging) {
 
   { // Read new tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("new title", song.title());
-    EXPECT_EQ("new artist", song.artist());
-    EXPECT_EQ("new album", song.album());
-    EXPECT_EQ("new album artist", song.albumartist());
-    EXPECT_EQ("new composer", song.composer());
-    EXPECT_EQ("new performer", song.performer());
-    EXPECT_EQ("new grouping", song.grouping());
+    EXPECT_EQ(QStringLiteral("new title"), song.title());
+    EXPECT_EQ(QStringLiteral("new artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("new album"), song.album());
+    EXPECT_EQ(QStringLiteral("new album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("new composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("new performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("new grouping"), song.grouping());
     EXPECT_EQ(4321, song.disc());
-    EXPECT_EQ("new genre", song.genre());
-    EXPECT_EQ("new comment", song.comment());
-    EXPECT_EQ("new lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("new genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("new comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("new lyrics"), song.lyrics());
     EXPECT_EQ(21, song.track());
     EXPECT_EQ(9102, song.year());
   }
 
   { // Write original tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -1525,16 +1525,16 @@ TEST_F(TagReaderTest, TestMP3AudioFileTagging) {
 
   { // Read original tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -1558,7 +1558,7 @@ TEST_F(TagReaderTest, TestMP3AudioFileTagging) {
 
 TEST_F(TagReaderTest, TestM4AAudioFileTagging) {
 
-  TemporaryResource r(":/audio/strawberry.m4a");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.m4a"));
 
   QString sha256sum_notags = SHA256SUM(r.fileName());
   EXPECT_FALSE(sha256sum_notags.isEmpty());
@@ -1567,7 +1567,7 @@ TEST_F(TagReaderTest, TestM4AAudioFileTagging) {
     QByteArray orig_file_data;
     QByteArray temp_file_data;
     {
-      QFile orig_file(":/audio/strawberry.m4a");
+      QFile orig_file(QStringLiteral(":/audio/strawberry.m4a"));
       orig_file.open(QIODevice::ReadOnly);
       EXPECT_TRUE(orig_file.isOpen());
       orig_file_data = orig_file.readAll();
@@ -1592,16 +1592,16 @@ TEST_F(TagReaderTest, TestM4AAudioFileTagging) {
 
   { // Write tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -1614,16 +1614,16 @@ TEST_F(TagReaderTest, TestM4AAudioFileTagging) {
 
   { // Read tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    //EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    //EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -1632,16 +1632,16 @@ TEST_F(TagReaderTest, TestM4AAudioFileTagging) {
 
   { // Write new tags
     Song song;
-    song.set_title("new title");
-    song.set_artist("new artist");
-    song.set_album("new album");
-    song.set_albumartist("new album artist");
-    song.set_composer("new composer");
-    song.set_performer("new performer");
-    song.set_grouping("new grouping");
-    song.set_genre("new genre");
-    song.set_comment("new comment");
-    song.set_lyrics("new lyrics");
+    song.set_title(QStringLiteral("new title"));
+    song.set_artist(QStringLiteral("new artist"));
+    song.set_album(QStringLiteral("new album"));
+    song.set_albumartist(QStringLiteral("new album artist"));
+    song.set_composer(QStringLiteral("new composer"));
+    song.set_performer(QStringLiteral("new performer"));
+    song.set_grouping(QStringLiteral("new grouping"));
+    song.set_genre(QStringLiteral("new genre"));
+    song.set_comment(QStringLiteral("new comment"));
+    song.set_lyrics(QStringLiteral("new lyrics"));
     song.set_track(21);
     song.set_disc(4321);
     song.set_year(9102);
@@ -1650,16 +1650,16 @@ TEST_F(TagReaderTest, TestM4AAudioFileTagging) {
 
   { // Read new tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("new title", song.title());
-    EXPECT_EQ("new artist", song.artist());
-    EXPECT_EQ("new album", song.album());
-    EXPECT_EQ("new album artist", song.albumartist());
-    EXPECT_EQ("new composer", song.composer());
-    //EXPECT_EQ("new performer", song.performer());
-    EXPECT_EQ("new grouping", song.grouping());
-    EXPECT_EQ("new genre", song.genre());
-    EXPECT_EQ("new comment", song.comment());
-    EXPECT_EQ("new lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("new title"), song.title());
+    EXPECT_EQ(QStringLiteral("new artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("new album"), song.album());
+    EXPECT_EQ(QStringLiteral("new album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("new composer"), song.composer());
+    //EXPECT_EQ(QStringLiteral("new performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("new grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("new genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("new comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("new lyrics"), song.lyrics());
     EXPECT_EQ(21, song.track());
     EXPECT_EQ(4321, song.disc());
     EXPECT_EQ(9102, song.year());
@@ -1667,16 +1667,16 @@ TEST_F(TagReaderTest, TestM4AAudioFileTagging) {
 
   { // Write original tags
     Song song;
-    song.set_title("strawberry title");
-    song.set_artist("strawberry artist");
-    song.set_album("strawberry album");
-    song.set_albumartist("strawberry album artist");
-    song.set_composer("strawberry composer");
-    song.set_performer("strawberry performer");
-    song.set_grouping("strawberry grouping");
-    song.set_genre("strawberry genre");
-    song.set_comment("strawberry comment");
-    song.set_lyrics("strawberry lyrics");
+    song.set_title(QStringLiteral("strawberry title"));
+    song.set_artist(QStringLiteral("strawberry artist"));
+    song.set_album(QStringLiteral("strawberry album"));
+    song.set_albumartist(QStringLiteral("strawberry album artist"));
+    song.set_composer(QStringLiteral("strawberry composer"));
+    song.set_performer(QStringLiteral("strawberry performer"));
+    song.set_grouping(QStringLiteral("strawberry grouping"));
+    song.set_genre(QStringLiteral("strawberry genre"));
+    song.set_comment(QStringLiteral("strawberry comment"));
+    song.set_lyrics(QStringLiteral("strawberry lyrics"));
     song.set_track(12);
     song.set_disc(1234);
     song.set_year(2019);
@@ -1685,16 +1685,16 @@ TEST_F(TagReaderTest, TestM4AAudioFileTagging) {
 
   { // Read original tags
     Song song = ReadSongFromFile(r.fileName());
-    EXPECT_EQ("strawberry title", song.title());
-    EXPECT_EQ("strawberry artist", song.artist());
-    EXPECT_EQ("strawberry album", song.album());
-    EXPECT_EQ("strawberry album artist", song.albumartist());
-    EXPECT_EQ("strawberry composer", song.composer());
-    //EXPECT_EQ("strawberry performer", song.performer());
-    EXPECT_EQ("strawberry grouping", song.grouping());
-    EXPECT_EQ("strawberry genre", song.genre());
-    EXPECT_EQ("strawberry comment", song.comment());
-    EXPECT_EQ("strawberry lyrics", song.lyrics());
+    EXPECT_EQ(QStringLiteral("strawberry title"), song.title());
+    EXPECT_EQ(QStringLiteral("strawberry artist"), song.artist());
+    EXPECT_EQ(QStringLiteral("strawberry album"), song.album());
+    EXPECT_EQ(QStringLiteral("strawberry album artist"), song.albumartist());
+    EXPECT_EQ(QStringLiteral("strawberry composer"), song.composer());
+    //EXPECT_EQ(QStringLiteral("strawberry performer"), song.performer());
+    EXPECT_EQ(QStringLiteral("strawberry grouping"), song.grouping());
+    EXPECT_EQ(QStringLiteral("strawberry genre"), song.genre());
+    EXPECT_EQ(QStringLiteral("strawberry comment"), song.comment());
+    EXPECT_EQ(QStringLiteral("strawberry lyrics"), song.lyrics());
     EXPECT_EQ(12, song.track());
     EXPECT_EQ(1234, song.disc());
     EXPECT_EQ(2019, song.year());
@@ -1718,7 +1718,7 @@ TEST_F(TagReaderTest, TestM4AAudioFileTagging) {
 
 TEST_F(TagReaderTest, TestFLACAudioFileCompilation) {
 
-  TemporaryResource r(":/audio/strawberry.flac");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.flac"));
 
   {
     Song song;
@@ -1746,7 +1746,7 @@ TEST_F(TagReaderTest, TestFLACAudioFileCompilation) {
 
 TEST_F(TagReaderTest, TestWavPackAudioFileCompilation) {
 
-  TemporaryResource r(":/audio/strawberry.wv");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.wv"));
 
   {
     Song song;
@@ -1774,7 +1774,7 @@ TEST_F(TagReaderTest, TestWavPackAudioFileCompilation) {
 
 TEST_F(TagReaderTest, TestOggFLACAudioFileCompilation) {
 
-  TemporaryResource r(":/audio/strawberry.oga");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.oga"));
 
   {
     Song song;
@@ -1802,7 +1802,7 @@ TEST_F(TagReaderTest, TestOggFLACAudioFileCompilation) {
 
 TEST_F(TagReaderTest, TestOggVorbisAudioFileCompilation) {
 
-  TemporaryResource r(":/audio/strawberry.ogg");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.ogg"));
 
   {
     Song song;
@@ -1830,7 +1830,7 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFileCompilation) {
 
 TEST_F(TagReaderTest, TestOggOpusAudioFileCompilation) {
 
-  TemporaryResource r(":/audio/strawberry.opus");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.opus"));
 
   {
     Song song;
@@ -1858,7 +1858,7 @@ TEST_F(TagReaderTest, TestOggOpusAudioFileCompilation) {
 
 TEST_F(TagReaderTest, TestOggSpeexAudioFileCompilation) {
 
-  TemporaryResource r(":/audio/strawberry.spx");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.spx"));
 
   {
     Song song;
@@ -1886,7 +1886,7 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFileCompilation) {
 
 TEST_F(TagReaderTest, TestMP3AudioFileCompilation) {
 
-  TemporaryResource r(":/audio/strawberry.mp3");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.mp3"));
 
   {
     Song song;
@@ -1914,7 +1914,7 @@ TEST_F(TagReaderTest, TestMP3AudioFileCompilation) {
 
 TEST_F(TagReaderTest, TestMP4AudioFileCompilation) {
 
-  TemporaryResource r(":/audio/strawberry.m4a");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.m4a"));
 
   {
     Song song;
@@ -1944,7 +1944,7 @@ TEST_F(TagReaderTest, TestMP4AudioFileCompilation) {
 
 TEST_F(TagReaderTest, TestFLACAudioFilePlaycount) {
 
-  TemporaryResource r(":/audio/strawberry.flac");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.flac"));
 
   {
     Song song;
@@ -1961,7 +1961,7 @@ TEST_F(TagReaderTest, TestFLACAudioFilePlaycount) {
 
 TEST_F(TagReaderTest, TestWavPackAudioFilePlaycount) {
 
-  TemporaryResource r(":/audio/strawberry.wv");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.wv"));
 
   {
     Song song;
@@ -1978,7 +1978,7 @@ TEST_F(TagReaderTest, TestWavPackAudioFilePlaycount) {
 
 TEST_F(TagReaderTest, TestOggFLACAudioFilePlaycount) {
 
-  TemporaryResource r(":/audio/strawberry.oga");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.oga"));
 
   {
     Song song;
@@ -1995,7 +1995,7 @@ TEST_F(TagReaderTest, TestOggFLACAudioFilePlaycount) {
 
 TEST_F(TagReaderTest, TestOggVorbisAudioFilePlaycount) {
 
-  TemporaryResource r(":/audio/strawberry.ogg");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.ogg"));
 
   {
     Song song;
@@ -2012,7 +2012,7 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFilePlaycount) {
 
 TEST_F(TagReaderTest, TestOggOpusAudioFilePlaycount) {
 
-  TemporaryResource r(":/audio/strawberry.opus");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.opus"));
 
   {
     Song song;
@@ -2029,7 +2029,7 @@ TEST_F(TagReaderTest, TestOggOpusAudioFilePlaycount) {
 
 TEST_F(TagReaderTest, TestOggSpeexAudioFilePlaycount) {
 
-  TemporaryResource r(":/audio/strawberry.spx");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.spx"));
 
   {
     Song song;
@@ -2046,7 +2046,7 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFilePlaycount) {
 
 TEST_F(TagReaderTest, TestOggASFAudioFilePlaycount) {
 
-  TemporaryResource r(":/audio/strawberry.asf");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.asf"));
 
   {
     Song song;
@@ -2063,7 +2063,7 @@ TEST_F(TagReaderTest, TestOggASFAudioFilePlaycount) {
 
 TEST_F(TagReaderTest, TestMP3AudioFilePlaycount) {
 
-  TemporaryResource r(":/audio/strawberry.mp3");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.mp3"));
 
   {
     Song song;
@@ -2080,7 +2080,7 @@ TEST_F(TagReaderTest, TestMP3AudioFilePlaycount) {
 
 TEST_F(TagReaderTest, TestMP4AudioFilePlaycount) {
 
-  TemporaryResource r(":/audio/strawberry.m4a");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.m4a"));
 
   {
     Song song;
@@ -2099,7 +2099,7 @@ TEST_F(TagReaderTest, TestMP4AudioFilePlaycount) {
 
 TEST_F(TagReaderTest, TestFLACAudioFileRating) {
 
-  TemporaryResource r(":/audio/strawberry.flac");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.flac"));
 
   {
     Song song;
@@ -2116,7 +2116,7 @@ TEST_F(TagReaderTest, TestFLACAudioFileRating) {
 
 TEST_F(TagReaderTest, TestWavPackAudioFileRating) {
 
-  TemporaryResource r(":/audio/strawberry.wv");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.wv"));
 
   {
     Song song;
@@ -2133,7 +2133,7 @@ TEST_F(TagReaderTest, TestWavPackAudioFileRating) {
 
 TEST_F(TagReaderTest, TestOggFLACAudioFileRating) {
 
-  TemporaryResource r(":/audio/strawberry.oga");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.oga"));
 
   {
     Song song;
@@ -2150,7 +2150,7 @@ TEST_F(TagReaderTest, TestOggFLACAudioFileRating) {
 
 TEST_F(TagReaderTest, TestOggVorbisAudioFileRating) {
 
-  TemporaryResource r(":/audio/strawberry.ogg");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.ogg"));
 
   {
     Song song;
@@ -2167,7 +2167,7 @@ TEST_F(TagReaderTest, TestOggVorbisAudioFileRating) {
 
 TEST_F(TagReaderTest, TestOggOpusAudioFileRating) {
 
-  TemporaryResource r(":/audio/strawberry.opus");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.opus"));
 
   {
     Song song;
@@ -2184,7 +2184,7 @@ TEST_F(TagReaderTest, TestOggOpusAudioFileRating) {
 
 TEST_F(TagReaderTest, TestOggSpeexAudioFileRating) {
 
-  TemporaryResource r(":/audio/strawberry.spx");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.spx"));
 
   {
     Song song;
@@ -2201,7 +2201,7 @@ TEST_F(TagReaderTest, TestOggSpeexAudioFileRating) {
 
 TEST_F(TagReaderTest, TestASFAudioFileRating) {
 
-  TemporaryResource r(":/audio/strawberry.asf");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.asf"));
 
   {
     Song song;
@@ -2218,7 +2218,7 @@ TEST_F(TagReaderTest, TestASFAudioFileRating) {
 
 TEST_F(TagReaderTest, TestMP3AudioFileRating) {
 
-  TemporaryResource r(":/audio/strawberry.mp3");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.mp3"));
 
   {
     Song song;
@@ -2235,7 +2235,7 @@ TEST_F(TagReaderTest, TestMP3AudioFileRating) {
 
 TEST_F(TagReaderTest, TestMP4AudioFileRating) {
 
-  TemporaryResource r(":/audio/strawberry.m4a");
+  TemporaryResource r(QStringLiteral(":/audio/strawberry.m4a"));
 
   {
     Song song;
diff --git a/tests/src/test_utils.cpp b/tests/src/test_utils.cpp
index f3851a59..d3520ca0 100644
--- a/tests/src/test_utils.cpp
+++ b/tests/src/test_utils.cpp
@@ -62,7 +62,7 @@ void PrintTo(const ::QUrl &url, std::ostream &os) {
 
 TemporaryResource::TemporaryResource(const QString &filename, QObject *parent) : QTemporaryFile(parent) {
 
-  setFileTemplate(QDir::tempPath() + "/strawberry_test-XXXXXX." + filename.section('.', -1, -1));
+  setFileTemplate(QDir::tempPath() + QStringLiteral("/strawberry_test-XXXXXX.") + filename.section(QLatin1Char('.'), -1, -1));
   open();
 
   QFile resource(filename);
diff --git a/tests/src/utilities_test.cpp b/tests/src/utilities_test.cpp
index f100df23..5197d33a 100644
--- a/tests/src/utilities_test.cpp
+++ b/tests/src/utilities_test.cpp
@@ -38,21 +38,21 @@
 
 TEST(UtilitiesTest, PrettyTimeDelta) {
 
-  ASSERT_EQ(Utilities::PrettyTimeDelta(60), "+1:00");
+  ASSERT_EQ(Utilities::PrettyTimeDelta(60), QStringLiteral("+1:00"));
 
-  ASSERT_EQ(Utilities::PrettyTimeDelta(3600), "+1:00:00");
+  ASSERT_EQ(Utilities::PrettyTimeDelta(3600), QStringLiteral("+1:00:00"));
 
-  ASSERT_EQ(Utilities::PrettyTimeDelta(9600), "+2:40:00");
+  ASSERT_EQ(Utilities::PrettyTimeDelta(9600), QStringLiteral("+2:40:00"));
 
 }
 
 TEST(UtilitiesTest, PrettyTime) {
 
-  ASSERT_EQ(Utilities::PrettyTime(60), "1:00");
+  ASSERT_EQ(Utilities::PrettyTime(60), QStringLiteral("1:00"));
 
-  ASSERT_EQ(Utilities::PrettyTime(3600), "1:00:00");
+  ASSERT_EQ(Utilities::PrettyTime(3600), QStringLiteral("1:00:00"));
 
-  ASSERT_EQ(Utilities::PrettyTime(9600), "2:40:00");
+  ASSERT_EQ(Utilities::PrettyTime(9600), QStringLiteral("2:40:00"));
 
 }
 
@@ -60,7 +60,7 @@ TEST(UtilitiesTest, PrettyTimeNanosec) {}
 
 TEST(UtilitiesTest, WordyTime) {
 
-  ASSERT_EQ(Utilities::WordyTime(787200), "9 days 2:40:00");
+  ASSERT_EQ(Utilities::WordyTime(787200), QStringLiteral("9 days 2:40:00"));
 
 }
 
@@ -68,7 +68,7 @@ TEST(UtilitiesTest, WordyTimeNanosec) {}
 
 TEST(UtilitiesTest, Ago) {
 
-  ASSERT_EQ(Utilities::Ago(QDateTime::currentDateTime().toSecsSinceEpoch() - 604800, QLocale()), "7 days ago");
+  ASSERT_EQ(Utilities::Ago(QDateTime::currentDateTime().toSecsSinceEpoch() - 604800, QLocale()), QStringLiteral("7 days ago"));
 
 }
 
@@ -76,87 +76,87 @@ TEST(UtilitiesTest, PrettyFutureDate) {}
 
 TEST(UtilitiesTest, PrettySize) {
 
-  ASSERT_EQ(Utilities::PrettySize(787200), "787.2 KB");
+  ASSERT_EQ(Utilities::PrettySize(787200), QStringLiteral("787.2 KB"));
 
 }
 
 TEST(UtilitiesTest, ColorToRgba) {
 
-  ASSERT_EQ(Utilities::ColorToRgba(QColor(33, 22, 128)), "rgba(33, 22, 128, 255)");
+  ASSERT_EQ(Utilities::ColorToRgba(QColor(33, 22, 128)), QStringLiteral("rgba(33, 22, 128, 255)"));
 
 }
 
 TEST(UtilitiesTest, HmacFunctions) {
 
-  QString key("key");
-  QString data("The quick brown fox jumps over the lazy dog");
+  QString key(QStringLiteral("key"));
+  QString data(QStringLiteral("The quick brown fox jumps over the lazy dog"));
 
   // Test Hmac MD5
-  QString result_hash_md5 = Utilities::HmacMd5(key.toLocal8Bit(), data.toLocal8Bit()).toHex();
-  bool result_md5 = result_hash_md5 == QString("80070713463e7749b90c2dc24911e275");
+  QString result_hash_md5 = QString::fromLatin1(Utilities::HmacMd5(key.toLocal8Bit(), data.toLocal8Bit()).toHex());
+  bool result_md5 = result_hash_md5 == QStringLiteral("80070713463e7749b90c2dc24911e275");
   EXPECT_TRUE(result_md5);
 
   // Test Hmac SHA256
-  QString result_hash_sha256 = Utilities::HmacSha256(key.toLocal8Bit(), data.toLocal8Bit()).toHex();
-  bool result_sha256 = result_hash_sha256 == QString("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8");
+  QString result_hash_sha256 = QString::fromLatin1(Utilities::HmacSha256(key.toLocal8Bit(), data.toLocal8Bit()).toHex());
+  bool result_sha256 = result_hash_sha256 == QStringLiteral("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8");
   EXPECT_TRUE(result_sha256);
 
 }
 
 TEST(UtilitiesTest, PrettySize2) {
 
-  ASSERT_EQ(Utilities::PrettySize(QSize(22, 32)), "22x32");
+  ASSERT_EQ(Utilities::PrettySize(QSize(22, 32)), QStringLiteral("22x32"));
 
 }
 
 TEST(UtilitiesTest, ParseRFC822DateTime) {
 
-  QDateTime result_DateTime = Utilities::ParseRFC822DateTime(QString("22 Feb 2008 00:16:17 GMT"));
+  QDateTime result_DateTime = Utilities::ParseRFC822DateTime(QStringLiteral("22 Feb 2008 00:16:17 GMT"));
   EXPECT_TRUE(result_DateTime.isValid());
 
-  result_DateTime = Utilities::ParseRFC822DateTime(QString("Thu, 13 Dec 2012 13:27:52 +0000"));
+  result_DateTime = Utilities::ParseRFC822DateTime(QStringLiteral("Thu, 13 Dec 2012 13:27:52 +0000"));
   EXPECT_TRUE(result_DateTime.isValid());
 
-  result_DateTime = Utilities::ParseRFC822DateTime(QString("Mon, 12 March 2012 20:00:00 +0100"));
+  result_DateTime = Utilities::ParseRFC822DateTime(QStringLiteral("Mon, 12 March 2012 20:00:00 +0100"));
   EXPECT_TRUE(result_DateTime.isValid());
 
 }
 
 TEST(UtilitiesTest, DecodeHtmlEntities) {
 
-  ASSERT_EQ(Utilities::DecodeHtmlEntities("&amp;"), "&");
-  ASSERT_EQ(Utilities::DecodeHtmlEntities("&#38;"), "&");
-  ASSERT_EQ(Utilities::DecodeHtmlEntities("&quot;"), "\"");
-  ASSERT_EQ(Utilities::DecodeHtmlEntities("&#34;"), "\"");
-  ASSERT_EQ(Utilities::DecodeHtmlEntities("&apos;"), "'");
-  ASSERT_EQ(Utilities::DecodeHtmlEntities("&#39;"), "'");
-  ASSERT_EQ(Utilities::DecodeHtmlEntities("&lt;"), "<");
-  ASSERT_EQ(Utilities::DecodeHtmlEntities("&#60;"), "<");
-  ASSERT_EQ(Utilities::DecodeHtmlEntities("&gt;"), ">");
-  ASSERT_EQ(Utilities::DecodeHtmlEntities("&#62;"), ">");
+  ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&amp;")), QStringLiteral("&"));
+  ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&#38;")), QStringLiteral("&"));
+  ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&quot;")), QStringLiteral("\""));
+  ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&#34;")), QStringLiteral("\""));
+  ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&apos;")), QStringLiteral("'"));
+  ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&#39;")), QStringLiteral("'"));
+  ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&lt;")), QStringLiteral("<"));
+  ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&#60;")), QStringLiteral("<"));
+  ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&gt;")), QStringLiteral(">"));
+  ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&#62;")), QStringLiteral(">"));
 
 }
 
 TEST(UtilitiesTest, PathWithoutFilenameExtension) {
 
-  ASSERT_EQ(Utilities::PathWithoutFilenameExtension("/home/jonas/test/filename.txt"), "/home/jonas/test/filename");
+  ASSERT_EQ(Utilities::PathWithoutFilenameExtension(QStringLiteral("/home/jonas/test/filename.txt")), QStringLiteral("/home/jonas/test/filename"));
 
 }
 
 TEST(UtilitiesTest, FiddleFileExtension) {
 
-  ASSERT_EQ(Utilities::FiddleFileExtension("/home/jonas/test/filename.txt", "db"), "/home/jonas/test/filename.db");
+  ASSERT_EQ(Utilities::FiddleFileExtension(QStringLiteral("/home/jonas/test/filename.txt"), QStringLiteral("db")), QStringLiteral("/home/jonas/test/filename.db"));
 
 }
 
 TEST(UtilitiesTest, SetEnvGetEnv) {
 
-  QString var = "STRAWBERRY_UNIT_TEST_" + Utilities::GetRandomStringWithCharsAndNumbers(20);
-  QString value = "STRAWBERRY_UNIT_TEST_" + Utilities::GetRandomStringWithCharsAndNumbers(20);
+  QString var = QStringLiteral("STRAWBERRY_UNIT_TEST_") + Utilities::GetRandomStringWithCharsAndNumbers(20);
+  QString value = QStringLiteral("STRAWBERRY_UNIT_TEST_") + Utilities::GetRandomStringWithCharsAndNumbers(20);
 
   Utilities::SetEnv(var.toUtf8().constData(), value);
   ASSERT_EQ(Utilities::GetEnv(var), value);
-  Utilities::SetEnv(var.toUtf8().constData(), "");
+  Utilities::SetEnv(var.toUtf8().constData(), QLatin1String(""));
 
 }
 
@@ -168,13 +168,13 @@ TEST(UtilitiesTest, Random) {
 
   EXPECT_FALSE(Utilities::CryptographicRandomString(20) == Utilities::CryptographicRandomString(20));
 
-  EXPECT_FALSE(Utilities::GetRandomString(20, "&%XVBGQ") == Utilities::GetRandomString(20, "&%XVBGQ"));
+  EXPECT_FALSE(Utilities::GetRandomString(20, QStringLiteral("&%XVBGQ")) == Utilities::GetRandomString(20, QStringLiteral("&%XVBGQ")));
 
 }
 
 TEST(UtilitiesTest, Transliterate) {
 
-  ASSERT_EQ(Utilities::Transliterate("ÆØÅ"), "AEOA");
+  ASSERT_EQ(Utilities::Transliterate(QStringLiteral("ÆØÅ")), QStringLiteral("AEOA"));
 
 }
 
@@ -194,29 +194,29 @@ TEST(UtilitiesTest, ReplaceVariable) {
   song.set_performer(Utilities::GetRandomStringWithChars(8));
   song.set_grouping(Utilities::GetRandomStringWithChars(8));
   song.set_length_nanosec(900000000000);
-  song.set_url(QUrl("file:///home/jonas/Music/test_song.flac"));
+  song.set_url(QUrl(QStringLiteral("file:///home/jonas/Music/test_song.flac")));
   song.set_skipcount(20);
   song.set_playcount(90);
   song.set_rating(1.0);
 
-  ASSERT_EQ(Utilities::ReplaceVariable("%title%", song, ""), song.title());
-  ASSERT_EQ(Utilities::ReplaceVariable("%album%", song, ""), song.album());
-  ASSERT_EQ(Utilities::ReplaceVariable("%artist%", song, ""), song.artist());
-  ASSERT_EQ(Utilities::ReplaceVariable("%albumartist%", song, ""), song.effective_albumartist());
-  ASSERT_EQ(Utilities::ReplaceVariable("%track%", song, ""), QString::number(song.track()));
-  ASSERT_EQ(Utilities::ReplaceVariable("%disc%", song, ""), QString::number(song.disc()));
-  ASSERT_EQ(Utilities::ReplaceVariable("%year%", song, ""), QString::number(song.year()));
-  ASSERT_EQ(Utilities::ReplaceVariable("%originalyear%", song, ""), QString::number(song.originalyear()));
-  ASSERT_EQ(Utilities::ReplaceVariable("%genre%", song, ""), song.genre());
-  ASSERT_EQ(Utilities::ReplaceVariable("%composer%", song, ""), song.composer());
-  ASSERT_EQ(Utilities::ReplaceVariable("%performer%", song, ""), song.performer());
-  ASSERT_EQ(Utilities::ReplaceVariable("%grouping%", song, ""), song.grouping());
-  ASSERT_EQ(Utilities::ReplaceVariable("%length%", song, ""), song.PrettyLength());
-  ASSERT_EQ(Utilities::ReplaceVariable("%filename%", song, ""), song.basefilename());
-  ASSERT_EQ(Utilities::ReplaceVariable("%url%", song, ""), song.url().toString());
-  ASSERT_EQ(Utilities::ReplaceVariable("%playcount%", song, ""), QString::number(song.playcount()));
-  ASSERT_EQ(Utilities::ReplaceVariable("%skipcount%", song, ""), QString::number(song.skipcount()));
-  ASSERT_EQ(Utilities::ReplaceVariable("%rating%", song, ""), song.PrettyRating());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%title%"), song, QLatin1String("")), song.title());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%album%"), song, QLatin1String("")), song.album());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%artist%"), song, QLatin1String("")), song.artist());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%albumartist%"), song, QLatin1String("")), song.effective_albumartist());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%track%"), song, QLatin1String("")), QString::number(song.track()));
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%disc%"), song, QLatin1String("")), QString::number(song.disc()));
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%year%"), song, QLatin1String("")), QString::number(song.year()));
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%originalyear%"), song, QLatin1String("")), QString::number(song.originalyear()));
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%genre%"), song, QLatin1String("")), song.genre());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%composer%"), song, QLatin1String("")), song.composer());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%performer%"), song, QLatin1String("")), song.performer());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%grouping%"), song, QLatin1String("")), song.grouping());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%length%"), song, QLatin1String("")), song.PrettyLength());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%filename%"), song, QLatin1String("")), song.basefilename());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%url%"), song, QLatin1String("")), song.url().toString());
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%playcount%"), song, QLatin1String("")), QString::number(song.playcount()));
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%skipcount%"), song, QLatin1String("")), QString::number(song.skipcount()));
+  ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%rating%"), song, QLatin1String("")), song.PrettyRating());
 
 }
 
@@ -236,11 +236,11 @@ TEST(UtilitiesTest, ReplaceMessage) {
   song.set_performer(Utilities::GetRandomStringWithChars(8));
   song.set_grouping(Utilities::GetRandomStringWithChars(8));
   song.set_length_nanosec(900000000000);
-  song.set_url(QUrl("file:///home/jonas/Music/test_song.flac"));
+  song.set_url(QUrl(QStringLiteral("file:///home/jonas/Music/test_song.flac")));
   song.set_skipcount(20);
   song.set_playcount(90);
   song.set_rating(1.0);
 
-  ASSERT_EQ(Utilities::ReplaceMessage("%title% - %artist%", song, ""), song.title() + " - " + song.artist());
+  ASSERT_EQ(Utilities::ReplaceMessage(QStringLiteral("%title% - %artist%"), song, QLatin1String("")), song.title() + QStringLiteral(" - ") + song.artist());
 
 }