Funkwhale
/
strawberry-audio-player-windows-mac-linux
mirror of https://github.com/strawberrymusicplayer/strawberry
1
0
Fork 0
Code Issues Releases Wiki Activity

tests: Use QStringLiteral

This commit is contained in:
Jonas Kvinge 2024-04-21 19:37:39 +02:00
parent c3f596e64e
commit c1a49da385
10 changed files with 959 additions and 959 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
tests/src/collectionbackend_test.cpp
View File

@ -47,14 +47,14 @@ class CollectionBackendTest : public ::testing::Test {
void SetUp() override { void SetUp() override {
database_.reset(new MemoryDatabase(nullptr)); database_.reset(new MemoryDatabase(nullptr));
backend_ = make_unique<CollectionBackend>(); 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) { static Song MakeDummySong(int directory_id) {
// Returns a valid song with all the required fields set // Returns a valid song with all the required fields set
Song ret; Song ret;
ret.set_directory_id(directory_id); 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_mtime(1);
ret.set_ctime(1); ret.set_ctime(1);
ret.set_filesize(1); ret.set_filesize(1);
@ -80,12 +80,12 @@ TEST_F(CollectionBackendTest, AddDirectory) {
QSignalSpy spy(&*backend_, &CollectionBackend::DirectoryDiscovered); QSignalSpy spy(&*backend_, &CollectionBackend::DirectoryDiscovered);
backend_->AddDirectory("/tmp"); backend_->AddDirectory(QStringLiteral("/tmp"));
// Check the signal was emitted correctly // Check the signal was emitted correctly
ASSERT_EQ(1, spy.count()); ASSERT_EQ(1, spy.count());
CollectionDirectory dir = spy[0][0].value<CollectionDirectory>(); 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(1, dir.id);
EXPECT_EQ(0, spy[0][1].value<CollectionSubdirectoryList>().size()); EXPECT_EQ(0, spy[0][1].value<CollectionSubdirectoryList>().size());
@ -96,7 +96,7 @@ TEST_F(CollectionBackendTest, RemoveDirectory) {
// Add a directory // Add a directory
CollectionDirectory dir; CollectionDirectory dir;
dir.id = 1; dir.id = 1;
dir.path = "/tmp"; dir.path = QStringLiteral("/tmp");
backend_->AddDirectory(dir.path); backend_->AddDirectory(dir.path);
QSignalSpy spy(&*backend_, &CollectionBackend::DirectoryDeleted); QSignalSpy spy(&*backend_, &CollectionBackend::DirectoryDeleted);
@ -107,7 +107,7 @@ TEST_F(CollectionBackendTest, RemoveDirectory) {
// Check the signal was emitted correctly // Check the signal was emitted correctly
ASSERT_EQ(1, spy.count()); ASSERT_EQ(1, spy.count());
dir = spy[0][0].value<CollectionDirectory>(); dir = spy[0][0].value<CollectionDirectory>();
EXPECT_EQ("/tmp", dir.path); EXPECT_EQ(QStringLiteral("/tmp"), dir.path);
EXPECT_EQ(1, dir.id); EXPECT_EQ(1, dir.id);
} }
@ -121,14 +121,14 @@ class SingleSong : public CollectionBackendTest {
CollectionBackendTest::SetUp(); CollectionBackendTest::SetUp();
// Add a directory - this will get ID 1 // Add a directory - this will get ID 1
backend_->AddDirectory("/tmp"); backend_->AddDirectory(QStringLiteral("/tmp"));
// Make a song in that directory // Make a song in that directory
song_ = MakeDummySong(1); song_ = MakeDummySong(1);
song_.set_title("Title"); song_.set_title(QStringLiteral("Title"));
song_.set_artist("Artist"); song_.set_artist(QStringLiteral("Artist"));
song_.set_album("Album"); song_.set_album(QStringLiteral("Album"));
song_.set_url(QUrl::fromLocalFile("foo.flac")); song_.set_url(QUrl::fromLocalFile(QStringLiteral("foo.flac")));
} }
void AddDummySong() { void AddDummySong() {
@ -157,15 +157,15 @@ class SingleSong : public CollectionBackendTest {
TEST_F(SingleSong, GetSongWithNoAlbum) { TEST_F(SingleSong, GetSongWithNoAlbum) {
song_.set_album(""); song_.set_album(QLatin1String(""));
AddDummySong(); AddDummySong();
if (HasFatalFailure()) return; if (HasFatalFailure()) return;
EXPECT_EQ(1, backend_->GetAllArtists().size()); EXPECT_EQ(1, backend_->GetAllArtists().size());
CollectionBackend::AlbumList albums = backend_->GetAllAlbums(); CollectionBackend::AlbumList albums = backend_->GetAllAlbums();
EXPECT_EQ(1, albums.size()); EXPECT_EQ(1, albums.size());
EXPECT_EQ("Artist", albums[0].album_artist); EXPECT_EQ(QStringLiteral("Artist"), albums[0].album_artist);
EXPECT_EQ("", albums[0].album); EXPECT_EQ(QLatin1String(""), albums[0].album);
} }
@ -197,7 +197,7 @@ TEST_F(SingleSong, GetAlbumsByArtist) {
AddDummySong(); AddDummySong();
if (HasFatalFailure()) return; if (HasFatalFailure()) return;
CollectionBackend::AlbumList albums = backend_->GetAlbumsByArtist("Artist"); CollectionBackend::AlbumList albums = backend_->GetAlbumsByArtist(QStringLiteral("Artist"));
ASSERT_EQ(1, albums.size()); ASSERT_EQ(1, albums.size());
EXPECT_EQ(song_.album(), albums[0].album); EXPECT_EQ(song_.album(), albums[0].album);
EXPECT_EQ(song_.artist(), albums[0].album_artist); EXPECT_EQ(song_.artist(), albums[0].album_artist);
@ -209,7 +209,7 @@ TEST_F(SingleSong, GetAlbumArt) {
AddDummySong(); AddDummySong();
if (HasFatalFailure()) return; 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_.album(), album.album);
EXPECT_EQ(song_.effective_albumartist(), album.album_artist); EXPECT_EQ(song_.effective_albumartist(), album.album_artist);
@ -220,7 +220,7 @@ TEST_F(SingleSong, GetSongs) {
AddDummySong(); AddDummySong();
if (HasFatalFailure()) return; if (HasFatalFailure()) return;
SongList songs = backend_->GetAlbumSongs("Artist", "Album"); SongList songs = backend_->GetAlbumSongs(QStringLiteral("Artist"), QStringLiteral("Album"));
ASSERT_EQ(1, songs.size()); ASSERT_EQ(1, songs.size());
EXPECT_EQ(song_.album(), songs[0].album()); EXPECT_EQ(song_.album(), songs[0].album());
EXPECT_EQ(song_.artist(), songs[0].artist()); EXPECT_EQ(song_.artist(), songs[0].artist());
@ -263,7 +263,7 @@ TEST_F(SingleSong, UpdateSong) {
Song new_song(song_); Song new_song(song_);
new_song.set_id(1); 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 deleted_spy(&*backend_, &CollectionBackend::SongsDeleted);
QSignalSpy added_spy(&*backend_, &CollectionBackend::SongsDiscovered); 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())); SongList songs_deleted = *(reinterpret_cast<SongList*>(deleted_spy[0][0].data()));
ASSERT_EQ(1, songs_added.size()); ASSERT_EQ(1, songs_added.size());
ASSERT_EQ(1, songs_deleted.size()); ASSERT_EQ(1, songs_deleted.size());
EXPECT_EQ("Title", songs_deleted[0].title()); EXPECT_EQ(QStringLiteral("Title"), songs_deleted[0].title());
EXPECT_EQ("A different title", songs_added[0].title()); EXPECT_EQ(QStringLiteral("A different title"), songs_added[0].title());
EXPECT_EQ(1, songs_deleted[0].id()); EXPECT_EQ(1, songs_deleted[0].id());
EXPECT_EQ(1, songs_added[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())); SongList songs_deleted = *(reinterpret_cast<SongList*>(deleted_spy[0][0].data()));
ASSERT_EQ(1, songs_deleted.size()); 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()); EXPECT_EQ(1, songs_deleted[0].id());
// Check we can't retrieve that song any more // 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())); SongList songs_deleted = *(reinterpret_cast<SongList*>(deleted_spy[0][0].data()));
ASSERT_EQ(1, songs_deleted.size()); 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()); EXPECT_EQ(1, songs_deleted[0].id());
// Check the song is marked as deleted. // Check the song is marked as deleted.
@ -354,16 +354,16 @@ class TestUrls : public CollectionBackendTest {
protected: protected:
void SetUp() override { void SetUp() override {
CollectionBackendTest::SetUp(); CollectionBackendTest::SetUp();
backend_->AddDirectory("/mnt/music"); backend_->AddDirectory(QStringLiteral("/mnt/music"));
} }
}; };
TEST_F(TestUrls, TestUrls) { TEST_F(TestUrls, TestUrls) {
QStringList strings = QStringList() << "file:///mnt/music/01 - Pink Floyd - Echoes.flac" QStringList strings = QStringList() << QStringLiteral("file:///mnt/music/01 - Pink Floyd - Echoes.flac")
<< "file:///mnt/music/02 - Björn Afzelius - Det räcker nu.flac" << QStringLiteral("file:///mnt/music/02 - Björn Afzelius - Det räcker nu.flac")
<< "file:///mnt/music/03 - Vazelina Bilopphøggers - Bomull i øra.flac" << QStringLiteral("file:///mnt/music/03 - Vazelina Bilopphøggers - Bomull i øra.flac")
<< "file:///mnt/music/Test !#$%&'()-@^_`{}~..flac"; << QStringLiteral("file:///mnt/music/Test !#$%&'()-@^_`{}~..flac");
QList<QUrl> urls = QUrl::fromStringList(strings); QList<QUrl> urls = QUrl::fromStringList(strings);
SongList songs; SongList songs;
@ -371,13 +371,13 @@ TEST_F(TestUrls, TestUrls) {
for (const QUrl &url : urls) { for (const QUrl &url : urls) {
EXPECT_EQ(url, QUrl::fromEncoded(url.toString(QUrl::FullyEncoded).toUtf8())); 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 song(Song::Source::Collection);
song.set_directory_id(1); song.set_directory_id(1);
song.set_title("Test Title"); song.set_title(QStringLiteral("Test Title"));
song.set_album("Test Album"); song.set_album(QStringLiteral("Test Album"));
song.set_artist("Test Artist"); song.set_artist(QStringLiteral("Test Artist"));
song.set_url(url); song.set_url(url);
song.set_length_nanosec(kNsecPerSec); song.set_length_nanosec(kNsecPerSec);
song.set_mtime(1); song.set_mtime(1);
@ -417,9 +417,9 @@ TEST_F(TestUrls, TestUrls) {
QSqlDatabase db(database_->Connect()); QSqlDatabase db(database_->Connect());
QSqlQuery q(db); 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()); EXPECT_TRUE(q.exec());
while (q.next()) { while (q.next()) {
@ -435,18 +435,18 @@ class UpdateSongsBySongID : public CollectionBackendTest {
protected: protected:
void SetUp() override { void SetUp() override {
CollectionBackendTest::SetUp(); CollectionBackendTest::SetUp();
backend_->AddDirectory("/mnt/music"); backend_->AddDirectory(QStringLiteral("/mnt/music"));
} }
}; };
TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) { TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
QStringList song_ids = QStringList() << "song1" QStringList song_ids = QStringList() << QStringLiteral("song1")
<< "song2" << QStringLiteral("song2")
<< "song3" << QStringLiteral("song3")
<< "song4" << QStringLiteral("song4")
<< "song5" << QStringLiteral("song5")
<< "song6"; << QStringLiteral("song6");
{ // Add songs { // Add songs
SongMap songs; SongMap songs;
@ -454,15 +454,15 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
for (const QString &song_id : song_ids) { for (const QString &song_id : song_ids) {
QUrl url; QUrl url;
url.setScheme("file"); url.setScheme(QStringLiteral("file"));
url.setPath("/music/" + song_id); url.setPath(QStringLiteral("/music/") + song_id);
Song song(Song::Source::Collection); Song song(Song::Source::Collection);
song.set_song_id(song_id); song.set_song_id(song_id);
song.set_directory_id(1); song.set_directory_id(1);
song.set_title("Test Title " + song_id); song.set_title(QStringLiteral("Test Title ") + song_id);
song.set_album("Test Album"); song.set_album(QStringLiteral("Test Album"));
song.set_artist("Test Artist"); song.set_artist(QStringLiteral("Test Artist"));
song.set_url(url); song.set_url(url);
song.set_length_nanosec(kNsecPerSec); song.set_length_nanosec(kNsecPerSec);
song.set_mtime(1); song.set_mtime(1);
@ -495,7 +495,7 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
SongMap songs; SongMap songs;
{ {
QSqlDatabase db(database_->Connect()); 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)); EXPECT_TRUE(backend_->ExecCollectionQuery(&query, songs));
} }
@ -517,23 +517,23 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
SongMap songs; SongMap songs;
QStringList song_ids2 = QStringList() << "song1" QStringList song_ids2 = QStringList() << QStringLiteral("song1")
<< "song4" << QStringLiteral("song4")
<< "song5" << QStringLiteral("song5")
<< "song6"; << QStringLiteral("song6");
for (const QString &song_id : song_ids2) { for (const QString &song_id : song_ids2) {
QUrl url; QUrl url;
url.setScheme("file"); url.setScheme(QStringLiteral("file"));
url.setPath("/music/" + song_id); url.setPath(QStringLiteral("/music/") + song_id);
Song song(Song::Source::Collection); Song song(Song::Source::Collection);
song.set_song_id(song_id); song.set_song_id(song_id);
song.set_directory_id(1); song.set_directory_id(1);
song.set_title("Test Title " + song_id); song.set_title(QStringLiteral("Test Title ") + song_id);
song.set_album("Test Album"); song.set_album(QStringLiteral("Test Album"));
song.set_artist("Test Artist"); song.set_artist(QStringLiteral("Test Artist"));
song.set_url(url); song.set_url(url);
song.set_length_nanosec(kNsecPerSec); song.set_length_nanosec(kNsecPerSec);
song.set_mtime(1); song.set_mtime(1);
@ -551,8 +551,8 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
ASSERT_EQ(1, spy2.count()); ASSERT_EQ(1, spy2.count());
SongList deleted_songs = spy2[0][0].value<SongList>(); SongList deleted_songs = spy2[0][0].value<SongList>();
EXPECT_EQ(deleted_songs.count(), 2); EXPECT_EQ(deleted_songs.count(), 2);
EXPECT_EQ(deleted_songs[0].song_id(), "song2"); EXPECT_EQ(deleted_songs[0].song_id(), QStringLiteral("song2"));
EXPECT_EQ(deleted_songs[1].song_id(), "song3"); EXPECT_EQ(deleted_songs[1].song_id(), QStringLiteral("song3"));
} }
@ -562,23 +562,23 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
SongMap songs; SongMap songs;
QStringList song_ids2 = QStringList() << "song1" QStringList song_ids2 = QStringList() << QStringLiteral("song1")
<< "song4" << QStringLiteral("song4")
<< "song5" << QStringLiteral("song5")
<< "song6"; << QStringLiteral("song6");
for (const QString &song_id : song_ids2) { for (const QString &song_id : song_ids2) {
QUrl url; QUrl url;
url.setScheme("file"); url.setScheme(QStringLiteral("file"));
url.setPath("/music/" + song_id); url.setPath(QStringLiteral("/music/") + song_id);
Song song(Song::Source::Collection); Song song(Song::Source::Collection);
song.set_song_id(song_id); song.set_song_id(song_id);
song.set_directory_id(1); song.set_directory_id(1);
song.set_title("Test Title " + song_id); song.set_title(QStringLiteral("Test Title ") + song_id);
song.set_album("Test Album"); song.set_album(QStringLiteral("Test Album"));
song.set_artist("Test Artist"); song.set_artist(QStringLiteral("Test Artist"));
song.set_url(url); song.set_url(url);
song.set_length_nanosec(kNsecPerSec); song.set_length_nanosec(kNsecPerSec);
song.set_mtime(1); song.set_mtime(1);
@ -590,8 +590,8 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
} }
songs["song1"].set_artist("New artist"); songs[QStringLiteral("song1")].set_artist(QStringLiteral("New artist"));
songs["song6"].set_artist("New artist"); songs[QStringLiteral("song6")].set_artist(QStringLiteral("New artist"));
backend_->UpdateSongsBySongID(songs); backend_->UpdateSongsBySongID(songs);
@ -601,10 +601,10 @@ TEST_F(UpdateSongsBySongID, UpdateSongsBySongID) {
SongList added_songs = spy2[0][0].value<SongList>(); SongList added_songs = spy2[0][0].value<SongList>();
EXPECT_EQ(deleted_songs.count(), 2); EXPECT_EQ(deleted_songs.count(), 2);
EXPECT_EQ(added_songs.count(), 2); EXPECT_EQ(added_songs.count(), 2);
EXPECT_EQ(deleted_songs[0].song_id(), "song1"); EXPECT_EQ(deleted_songs[0].song_id(), QStringLiteral("song1"));
EXPECT_EQ(deleted_songs[1].song_id(), "song6"); EXPECT_EQ(deleted_songs[1].song_id(), QStringLiteral("song6"));
EXPECT_EQ(added_songs[0].song_id(), "song1"); EXPECT_EQ(added_songs[0].song_id(), QStringLiteral("song1"));
EXPECT_EQ(added_songs[1].song_id(), "song6"); EXPECT_EQ(added_songs[1].song_id(), QStringLiteral("song6"));
} }

108
tests/src/collectionmodel_test.cpp
View File

@ -54,7 +54,7 @@ class CollectionModelTest : public ::testing::Test {
void SetUp() override { void SetUp() override {
database_ = make_shared<MemoryDatabase>(nullptr); database_ = make_shared<MemoryDatabase>(nullptr);
backend_ = make_shared<CollectionBackend>(); 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); model_ = make_unique<CollectionModel>(backend_, nullptr);
added_dir_ = false; added_dir_ = false;
@ -71,11 +71,11 @@ class CollectionModelTest : public ::testing::Test {
song.set_directory_id(1); song.set_directory_id(1);
if (song.mtime() == 0) song.set_mtime(1); if (song.mtime() == 0) song.set_mtime(1);
if (song.ctime() == 0) song.set_ctime(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 (song.filesize() == -1) song.set_filesize(1);
if (!added_dir_) { if (!added_dir_) {
backend_->AddDirectory("/tmp"); backend_->AddDirectory(QStringLiteral("/tmp"));
added_dir_ = true; added_dir_ = true;
} }
@ -105,24 +105,24 @@ TEST_F(CollectionModelTest, Initialization) {
TEST_F(CollectionModelTest, WithInitialArtists) { TEST_F(CollectionModelTest, WithInitialArtists) {
AddSong("Title", "Artist 1", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral("Artist 1"), QStringLiteral("Album"), 123);
AddSong("Title", "Artist 2", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral("Artist 2"), QStringLiteral("Album"), 123);
AddSong("Title", "Foo", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral("Foo"), QStringLiteral("Album"), 123);
model_->Init(false); model_->Init(false);
ASSERT_EQ(5, model_sorted_->rowCount(QModelIndex())); ASSERT_EQ(5, model_sorted_->rowCount(QModelIndex()));
EXPECT_EQ("A", model_sorted_->index(0, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("A"), model_sorted_->index(0, 0, QModelIndex()).data().toString());
EXPECT_EQ("Artist 1", model_sorted_->index(1, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("Artist 1"), model_sorted_->index(1, 0, QModelIndex()).data().toString());
EXPECT_EQ("Artist 2", model_sorted_->index(2, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("Artist 2"), model_sorted_->index(2, 0, QModelIndex()).data().toString());
EXPECT_EQ("F", model_sorted_->index(3, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("F"), model_sorted_->index(3, 0, QModelIndex()).data().toString());
EXPECT_EQ("Foo", model_sorted_->index(4, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("Foo"), model_sorted_->index(4, 0, QModelIndex()).data().toString());
} }
TEST_F(CollectionModelTest, CompilationAlbums) { TEST_F(CollectionModelTest, CompilationAlbums) {
Song song; Song song;
song.Init("Title", "Artist", "Album", 123); song.Init(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral("Album"), 123);
song.set_compilation(true); song.set_compilation(true);
song.set_mtime(0); song.set_mtime(0);
song.set_ctime(0); song.set_ctime(0);
@ -134,66 +134,66 @@ TEST_F(CollectionModelTest, CompilationAlbums) {
ASSERT_EQ(1, model_->rowCount(QModelIndex())); ASSERT_EQ(1, model_->rowCount(QModelIndex()));
QModelIndex va_index = model_->index(0, 0, 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)); EXPECT_TRUE(model_->hasChildren(va_index));
ASSERT_EQ(model_->rowCount(va_index), 1); ASSERT_EQ(model_->rowCount(va_index), 1);
QModelIndex album_index = model_->index(0, 0, va_index); 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)); EXPECT_TRUE(model_->hasChildren(album_index));
} }
TEST_F(CollectionModelTest, NumericHeaders) { TEST_F(CollectionModelTest, NumericHeaders) {
AddSong("Title", "1artist", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral("1artist"), QStringLiteral("Album"), 123);
AddSong("Title", "2artist", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral("2artist"), QStringLiteral("Album"), 123);
AddSong("Title", "0artist", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral("0artist"), QStringLiteral("Album"), 123);
AddSong("Title", "zartist", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral("zartist"), QStringLiteral("Album"), 123);
model_->Init(false); model_->Init(false);
ASSERT_EQ(6, model_sorted_->rowCount(QModelIndex())); ASSERT_EQ(6, model_sorted_->rowCount(QModelIndex()));
EXPECT_EQ("0-9", model_sorted_->index(0, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("0-9"), model_sorted_->index(0, 0, QModelIndex()).data().toString());
EXPECT_EQ("0artist", model_sorted_->index(1, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("0artist"), model_sorted_->index(1, 0, QModelIndex()).data().toString());
EXPECT_EQ("1artist", model_sorted_->index(2, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("1artist"), model_sorted_->index(2, 0, QModelIndex()).data().toString());
EXPECT_EQ("2artist", model_sorted_->index(3, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("2artist"), model_sorted_->index(3, 0, QModelIndex()).data().toString());
EXPECT_EQ("Z", model_sorted_->index(4, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("Z"), model_sorted_->index(4, 0, QModelIndex()).data().toString());
EXPECT_EQ("zartist", model_sorted_->index(5, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("zartist"), model_sorted_->index(5, 0, QModelIndex()).data().toString());
} }
TEST_F(CollectionModelTest, MixedCaseHeaders) { TEST_F(CollectionModelTest, MixedCaseHeaders) {
AddSong("Title", "Artist", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral("Album"), 123);
AddSong("Title", "artist", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral("artist"), QStringLiteral("Album"), 123);
model_->Init(false); model_->Init(false);
ASSERT_EQ(3, model_sorted_->rowCount(QModelIndex())); ASSERT_EQ(3, model_sorted_->rowCount(QModelIndex()));
EXPECT_EQ("A", model_sorted_->index(0, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("A"), model_sorted_->index(0, 0, QModelIndex()).data().toString());
EXPECT_EQ("Artist", model_sorted_->index(1, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("Artist"), model_sorted_->index(1, 0, QModelIndex()).data().toString());
EXPECT_EQ("artist", model_sorted_->index(2, 0, QModelIndex()).data().toString()); EXPECT_EQ(QStringLiteral("artist"), model_sorted_->index(2, 0, QModelIndex()).data().toString());
} }
TEST_F(CollectionModelTest, UnknownArtists) { TEST_F(CollectionModelTest, UnknownArtists) {
AddSong("Title", "", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral(""), QStringLiteral("Album"), 123);
model_->Init(false); model_->Init(false);
model_->fetchMore(model_->index(0, 0)); model_->fetchMore(model_->index(0, 0));
ASSERT_EQ(1, model_->rowCount(QModelIndex())); ASSERT_EQ(1, model_->rowCount(QModelIndex()));
QModelIndex unknown_index = model_->index(0, 0, 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)); 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) { TEST_F(CollectionModelTest, UnknownAlbums) {
AddSong("Title", "Artist", "", 123); AddSong(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral(""), 123);
AddSong("Title", "Artist", "Album", 123); AddSong(QStringLiteral("Title"), QStringLiteral("Artist"), QStringLiteral("Album"), 123);
model_->Init(false); model_->Init(false);
model_->fetchMore(model_->index(0, 0)); 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 unknown_album_index = model_->index(0, 0, artist_index);
QModelIndex real_album_index = model_->index(1, 0, artist_index); QModelIndex real_album_index = model_->index(1, 0, artist_index);
EXPECT_EQ("Unknown", unknown_album_index.data().toString()); EXPECT_EQ(QStringLiteral("Unknown"), unknown_album_index.data().toString());
EXPECT_EQ("Album", real_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) { for (int i=0 ; i < 4 ; ++i) {
QString n = QString::number(i+1); QString n = QString::number(i+1);
Song song; 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_mtime(0);
song.set_ctime(0); song.set_ctime(0);
songs << song; // clazy:exclude=reserve-candidates songs << song; // clazy:exclude=reserve-candidates
@ -224,7 +224,7 @@ TEST_F(CollectionModelTest, VariousArtistSongs) {
songs[0].set_compilation_detected(true); songs[0].set_compilation_detected(true);
songs[1].set_compilation(true); songs[1].set_compilation(true);
songs[2].set_compilation_on(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) for (int i=0 ; i < 4 ; ++i)
AddSong(songs[i]); AddSong(songs[i]);
@ -238,18 +238,18 @@ TEST_F(CollectionModelTest, VariousArtistSongs) {
model_->fetchMore(album_index); model_->fetchMore(album_index);
ASSERT_EQ(4, model_->rowCount(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(QStringLiteral("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(QStringLiteral("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(QStringLiteral("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("Title 4"), model_->index(3, 0, album_index).data().toString());
} }
TEST_F(CollectionModelTest, RemoveSongsLazyLoaded) { TEST_F(CollectionModelTest, RemoveSongsLazyLoaded) {
Song one = AddSong("Title 1", "Artist", "Album", 123); one.set_id(1); Song one = AddSong(QStringLiteral("Title 1"), QStringLiteral("Artist"), QStringLiteral("Album"), 123); one.set_id(1);
Song two = AddSong("Title 2", "Artist", "Album", 123); two.set_id(2); Song two = AddSong(QStringLiteral("Title 2"), QStringLiteral("Artist"), QStringLiteral("Album"), 123); two.set_id(2);
AddSong("Title 3", "Artist", "Album", 123); AddSong(QStringLiteral("Title 3"), QStringLiteral("Artist"), QStringLiteral("Album"), 123);
model_->Init(false); model_->Init(false);
// Lazy load the items // Lazy load the items
@ -275,14 +275,14 @@ TEST_F(CollectionModelTest, RemoveSongsLazyLoaded) {
ASSERT_EQ(1, model_->rowCount(artist_index)); ASSERT_EQ(1, model_->rowCount(artist_index));
album_index = model_->index(0, 0, artist_index); album_index = model_->index(0, 0, artist_index);
ASSERT_EQ(1, model_->rowCount(album_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) { TEST_F(CollectionModelTest, RemoveSongsNotLazyLoaded) {
Song one = AddSong("Title 1", "Artist", "Album", 123); one.set_id(1); Song one = AddSong(QStringLiteral("Title 1"), QStringLiteral("Artist"), QStringLiteral("Album"), 123); one.set_id(1);
Song two = AddSong("Title 2", "Artist", "Album", 123); two.set_id(2); Song two = AddSong(QStringLiteral("Title 2"), QStringLiteral("Artist"), QStringLiteral("Album"), 123); two.set_id(2);
model_->Init(false); model_->Init(false);
// Remove the first two songs // Remove the first two songs
@ -300,9 +300,9 @@ TEST_F(CollectionModelTest, RemoveSongsNotLazyLoaded) {
TEST_F(CollectionModelTest, RemoveEmptyAlbums) { TEST_F(CollectionModelTest, RemoveEmptyAlbums) {
Song one = AddSong("Title 1", "Artist", "Album 1", 123); one.set_id(1); Song one = AddSong(QStringLiteral("Title 1"), QStringLiteral("Artist"), QStringLiteral("Album 1"), 123); one.set_id(1);
Song two = AddSong("Title 2", "Artist", "Album 2", 123); two.set_id(2); Song two = AddSong(QStringLiteral("Title 2"), QStringLiteral("Artist"), QStringLiteral("Album 2"), 123); two.set_id(2);
Song three = AddSong("Title 3", "Artist", "Album 2", 123); three.set_id(3); Song three = AddSong(QStringLiteral("Title 3"), QStringLiteral("Artist"), QStringLiteral("Album 2"), 123); three.set_id(3);
model_->Init(false); model_->Init(false);
QModelIndex artist_index = model_->index(0, 0, QModelIndex()); QModelIndex artist_index = model_->index(0, 0, QModelIndex());
@ -318,16 +318,16 @@ TEST_F(CollectionModelTest, RemoveEmptyAlbums) {
ASSERT_EQ(1, model_->rowCount(artist_index)); ASSERT_EQ(1, model_->rowCount(artist_index));
QModelIndex album_index = model_->index(0, 0, artist_index); QModelIndex album_index = model_->index(0, 0, artist_index);
model_->fetchMore(album_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)); 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) { 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); model_->Init(false);
// Lazy load the items // Lazy load the items

2
tests/src/logging_env.h
View File

@ -30,7 +30,7 @@ class LoggingEnvironment : public ::testing::Environment {
LoggingEnvironment() = default; LoggingEnvironment() = default;
void SetUp() override { void SetUp() override {
logging::Init(); logging::Init();
logging::SetLevels("*:4"); logging::SetLevels(QStringLiteral("*:4"));
} }
private: private:
Q_DISABLE_COPY(LoggingEnvironment) Q_DISABLE_COPY(LoggingEnvironment)

46
tests/src/mergedproxymodel_test.cpp
View File

@ -41,15 +41,15 @@ class MergedProxyModelTest : public ::testing::Test {
TEST_F(MergedProxyModelTest, Flat) { TEST_F(MergedProxyModelTest, Flat) {
source_.appendRow(new QStandardItem("one")); source_.appendRow(new QStandardItem(QStringLiteral("one")));
source_.appendRow(new QStandardItem("two")); source_.appendRow(new QStandardItem(QStringLiteral("two")));
ASSERT_EQ(2, merged_.rowCount(QModelIndex())); ASSERT_EQ(2, merged_.rowCount(QModelIndex()));
QModelIndex one_i = merged_.index(0, 0, QModelIndex()); QModelIndex one_i = merged_.index(0, 0, QModelIndex());
QModelIndex two_i = merged_.index(1, 0, QModelIndex()); QModelIndex two_i = merged_.index(1, 0, QModelIndex());
EXPECT_EQ("one", one_i.data().toString()); EXPECT_EQ(QStringLiteral("one"), one_i.data().toString());
EXPECT_EQ("two", two_i.data().toString()); EXPECT_EQ(QStringLiteral("two"), two_i.data().toString());
EXPECT_FALSE(merged_.parent(one_i).isValid()); EXPECT_FALSE(merged_.parent(one_i).isValid());
EXPECT_FALSE(merged_.hasChildren(one_i)); EXPECT_FALSE(merged_.hasChildren(one_i));
@ -57,8 +57,8 @@ TEST_F(MergedProxyModelTest, Flat) {
TEST_F(MergedProxyModelTest, Tree) { TEST_F(MergedProxyModelTest, Tree) {
QStandardItem* one = new QStandardItem("one"); QStandardItem* one = new QStandardItem(QStringLiteral("one"));
QStandardItem* two = new QStandardItem("two"); QStandardItem* two = new QStandardItem(QStringLiteral("two"));
source_.appendRow(one); source_.appendRow(one);
one->appendRow(two); one->appendRow(two);
@ -68,31 +68,31 @@ TEST_F(MergedProxyModelTest, Tree) {
ASSERT_EQ(1, merged_.rowCount(one_i)); ASSERT_EQ(1, merged_.rowCount(one_i));
QModelIndex two_i = merged_.index(0, 0, one_i); QModelIndex two_i = merged_.index(0, 0, one_i);
EXPECT_EQ("one", one_i.data().toString()); EXPECT_EQ(QStringLiteral("one"), one_i.data().toString());
EXPECT_EQ("two", two_i.data().toString()); EXPECT_EQ(QStringLiteral("two"), two_i.data().toString());
EXPECT_EQ("one", two_i.parent().data().toString()); EXPECT_EQ(QStringLiteral("one"), two_i.parent().data().toString());
} }
TEST_F(MergedProxyModelTest, Merged) { TEST_F(MergedProxyModelTest, Merged) {
source_.appendRow(new QStandardItem("one")); source_.appendRow(new QStandardItem(QStringLiteral("one")));
QStandardItemModel submodel; QStandardItemModel submodel;
submodel.appendRow(new QStandardItem("two")); submodel.appendRow(new QStandardItem(QStringLiteral("two")));
merged_.AddSubModel(source_.index(0, 0, QModelIndex()), &submodel); merged_.AddSubModel(source_.index(0, 0, QModelIndex()), &submodel);
ASSERT_EQ(1, merged_.rowCount(QModelIndex())); ASSERT_EQ(1, merged_.rowCount(QModelIndex()));
QModelIndex one_i = merged_.index(0, 0, 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)); EXPECT_TRUE(merged_.hasChildren(one_i));
ASSERT_EQ(1, merged_.rowCount(one_i)); ASSERT_EQ(1, merged_.rowCount(one_i));
QModelIndex two_i = merged_.index(0, 0, 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_EQ(0, merged_.rowCount(two_i));
EXPECT_FALSE(merged_.hasChildren(two_i)); EXPECT_FALSE(merged_.hasChildren(two_i));
@ -103,7 +103,7 @@ TEST_F(MergedProxyModelTest, SourceInsert) {
QSignalSpy before_spy(&merged_, &MergedProxyModel::rowsAboutToBeInserted); QSignalSpy before_spy(&merged_, &MergedProxyModel::rowsAboutToBeInserted);
QSignalSpy after_spy(&merged_, &MergedProxyModel::rowsInserted); 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, before_spy.count());
ASSERT_EQ(1, after_spy.count()); ASSERT_EQ(1, after_spy.count());
@ -118,7 +118,7 @@ TEST_F(MergedProxyModelTest, SourceInsert) {
TEST_F(MergedProxyModelTest, SourceRemove) { TEST_F(MergedProxyModelTest, SourceRemove) {
source_.appendRow(new QStandardItem("one")); source_.appendRow(new QStandardItem(QStringLiteral("one")));
QSignalSpy before_spy(&merged_, &MergedProxyModel::rowsAboutToBeRemoved); QSignalSpy before_spy(&merged_, &MergedProxyModel::rowsAboutToBeRemoved);
QSignalSpy after_spy(&merged_, &MergedProxyModel::rowsRemoved); QSignalSpy after_spy(&merged_, &MergedProxyModel::rowsRemoved);
@ -138,21 +138,21 @@ TEST_F(MergedProxyModelTest, SourceRemove) {
TEST_F(MergedProxyModelTest, SubInsert) { TEST_F(MergedProxyModelTest, SubInsert) {
source_.appendRow(new QStandardItem("one")); source_.appendRow(new QStandardItem(QStringLiteral("one")));
QStandardItemModel submodel; QStandardItemModel submodel;
merged_.AddSubModel(source_.index(0, 0, QModelIndex()), &submodel); merged_.AddSubModel(source_.index(0, 0, QModelIndex()), &submodel);
QSignalSpy before_spy(&merged_, &MergedProxyModel::rowsAboutToBeInserted); QSignalSpy before_spy(&merged_, &MergedProxyModel::rowsAboutToBeInserted);
QSignalSpy after_spy(&merged_, &MergedProxyModel::rowsInserted); 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, before_spy.count());
ASSERT_EQ(1, after_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][1].toInt());
EXPECT_EQ(0, before_spy[0][2].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][1].toInt());
EXPECT_EQ(0, after_spy[0][2].toInt()); EXPECT_EQ(0, after_spy[0][2].toInt());
@ -160,11 +160,11 @@ TEST_F(MergedProxyModelTest, SubInsert) {
TEST_F(MergedProxyModelTest, SubRemove) { TEST_F(MergedProxyModelTest, SubRemove) {
source_.appendRow(new QStandardItem("one")); source_.appendRow(new QStandardItem(QStringLiteral("one")));
QStandardItemModel submodel; QStandardItemModel submodel;
merged_.AddSubModel(source_.index(0, 0, QModelIndex()), &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 before_spy(&merged_, &MergedProxyModel::rowsAboutToBeRemoved);
QSignalSpy after_spy(&merged_, &MergedProxyModel::rowsRemoved); QSignalSpy after_spy(&merged_, &MergedProxyModel::rowsRemoved);
@ -173,10 +173,10 @@ TEST_F(MergedProxyModelTest, SubRemove) {
ASSERT_EQ(1, before_spy.count()); ASSERT_EQ(1, before_spy.count());
ASSERT_EQ(1, after_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][1].toInt());
EXPECT_EQ(0, before_spy[0][2].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][1].toInt());
EXPECT_EQ(0, after_spy[0][2].toInt()); EXPECT_EQ(0, after_spy[0][2].toInt());

100
tests/src/organizeformat_test.cpp
View File

@ -40,124 +40,124 @@ protected:
TEST_F(OrganizeFormatTest, BasicReplace) { TEST_F(OrganizeFormatTest, BasicReplace) {
song_.set_title("title"); song_.set_title(QStringLiteral("title"));
song_.set_album("album"); song_.set_album(QStringLiteral("album"));
song_.set_artist("artist"); song_.set_artist(QStringLiteral("artist"));
song_.set_albumartist("albumartist"); song_.set_albumartist(QStringLiteral("albumartist"));
song_.set_track(321); song_.set_track(321);
song_.set_disc(789); song_.set_disc(789);
song_.set_year(2010); song_.set_year(2010);
song_.set_originalyear(1995); song_.set_originalyear(1995);
song_.set_genre("genre"); song_.set_genre(QStringLiteral("genre"));
song_.set_composer("composer"); song_.set_composer(QStringLiteral("composer"));
song_.set_performer("performer"); song_.set_performer(QStringLiteral("performer"));
song_.set_grouping("grouping"); song_.set_grouping(QStringLiteral("grouping"));
song_.set_comment("comment"); song_.set_comment(QStringLiteral("comment"));
song_.set_length_nanosec(987 * kNsecPerSec); song_.set_length_nanosec(987 * kNsecPerSec);
song_.set_samplerate(654); song_.set_samplerate(654);
song_.set_bitdepth(32); song_.set_bitdepth(32);
song_.set_bitrate(123); 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()); 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) { TEST_F(OrganizeFormatTest, BasicReplacePaths) {
song_.set_title("title"); song_.set_title(QStringLiteral("title"));
song_.set_album("album"); song_.set_album(QStringLiteral("album"));
song_.set_artist("artist"); song_.set_artist(QStringLiteral("artist"));
song_.set_albumartist("albumartist"); song_.set_albumartist(QStringLiteral("albumartist"));
song_.set_track(321); 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()); 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) { 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()); ASSERT_TRUE(format_.IsValid());
EXPECT_EQ("B", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("B"), format_.GetFilenameForSong(song_).filename);
} }
TEST_F(OrganizeFormatTest, AlbumArtistInitial) { 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()); ASSERT_TRUE(format_.IsValid());
EXPECT_EQ("B", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("B"), format_.GetFilenameForSong(song_).filename);
} }
TEST_F(OrganizeFormatTest, InvalidTag) { TEST_F(OrganizeFormatTest, InvalidTag) {
format_.set_format("%invalid"); format_.set_format(QStringLiteral("%invalid"));
EXPECT_FALSE(format_.IsValid()); EXPECT_FALSE(format_.IsValid());
} }
TEST_F(OrganizeFormatTest, Blocks) { TEST_F(OrganizeFormatTest, Blocks) {
format_.set_format("Before{Inside%year}After"); format_.set_format(QStringLiteral("Before{Inside%year}After"));
ASSERT_TRUE(format_.IsValid()); ASSERT_TRUE(format_.IsValid());
song_.set_year(-1); song_.set_year(-1);
EXPECT_EQ("BeforeAfter", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("BeforeAfter"), format_.GetFilenameForSong(song_).filename);
song_.set_year(0); song_.set_year(0);
EXPECT_EQ("BeforeAfter", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("BeforeAfter"), format_.GetFilenameForSong(song_).filename);
song_.set_year(123); song_.set_year(123);
EXPECT_EQ("BeforeInside123After", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("BeforeInside123After"), format_.GetFilenameForSong(song_).filename);
} }
TEST_F(OrganizeFormatTest, ReplaceSpaces) { TEST_F(OrganizeFormatTest, ReplaceSpaces) {
song_.set_title("The Song Title"); song_.set_title(QStringLiteral("The Song Title"));
format_.set_format("The Format String %title"); format_.set_format(QStringLiteral("The Format String %title"));
format_.set_replace_spaces(false); 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); 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) { TEST_F(OrganizeFormatTest, ReplaceNonAscii) {
song_.set_artist(QString::fromUtf8("Röyksopp")); song_.set_artist(QStringLiteral("Röyksopp"));
format_.set_format("%artist"); format_.set_format(QStringLiteral("%artist"));
format_.set_remove_non_ascii(false); 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); format_.set_remove_non_ascii(true);
EXPECT_EQ("Royksopp", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("Royksopp"), format_.GetFilenameForSong(song_).filename);
song_.set_artist(""); song_.set_artist(QLatin1String(""));
EXPECT_EQ("", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QLatin1String(""), format_.GetFilenameForSong(song_).filename);
#ifdef HAVE_ICU #ifdef HAVE_ICU
song_.set_artist(QString::fromUtf8("Владимир Высоцкий")); song_.set_artist(QStringLiteral("Владимир Высоцкий"));
EXPECT_EQ("Vladimir_Vysockij", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("Vladimir_Vysockij"), format_.GetFilenameForSong(song_).filename);
song_.set_artist(QString::fromUtf8("エックス・ジャパン")); song_.set_artist(QStringLiteral("エックス・ジャパン"));
EXPECT_EQ("ekkusujapan", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("ekkusujapan"), format_.GetFilenameForSong(song_).filename);
#endif #endif
@ -165,26 +165,26 @@ TEST_F(OrganizeFormatTest, ReplaceNonAscii) {
TEST_F(OrganizeFormatTest, TrackNumberPadding) { TEST_F(OrganizeFormatTest, TrackNumberPadding) {
format_.set_format("%track"); format_.set_format(QStringLiteral("%track"));
song_.set_track(9); song_.set_track(9);
EXPECT_EQ("09", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("09"), format_.GetFilenameForSong(song_).filename);
song_.set_track(99); song_.set_track(99);
EXPECT_EQ("99", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("99"), format_.GetFilenameForSong(song_).filename);
song_.set_track(999); song_.set_track(999);
EXPECT_EQ("999", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("999"), format_.GetFilenameForSong(song_).filename);
song_.set_track(0); song_.set_track(0);
EXPECT_EQ("", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QLatin1String(""), format_.GetFilenameForSong(song_).filename);
} }
TEST_F(OrganizeFormatTest, ReplaceSlashes) { TEST_F(OrganizeFormatTest, ReplaceSlashes) {
format_.set_format("%title"); format_.set_format(QStringLiteral("%title"));
song_.set_title("foo/bar\\baz"); song_.set_title(QStringLiteral("foo/bar\\baz"));
EXPECT_EQ("foobarbaz", format_.GetFilenameForSong(song_).filename); EXPECT_EQ(QStringLiteral("foobarbaz"), format_.GetFilenameForSong(song_).filename);
} }

98
tests/src/playlist_test.cpp
View File

@ -76,7 +76,7 @@ TEST_F(PlaylistTest, Basic) {
TEST_F(PlaylistTest, InsertItems) { 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); PlaylistItemPtr item_ptr(item);
// Insert the item // Insert the item
@ -85,22 +85,22 @@ TEST_F(PlaylistTest, InsertItems) {
ASSERT_EQ(1, playlist_.rowCount(QModelIndex())); ASSERT_EQ(1, playlist_.rowCount(QModelIndex()));
// Get the metadata // Get the metadata
EXPECT_EQ("Title", playlist_.data(playlist_.index(0, Playlist::Column_Title))); EXPECT_EQ(QStringLiteral("Title"), playlist_.data(playlist_.index(0, Playlist::Column_Title)));
EXPECT_EQ("Artist", playlist_.data(playlist_.index(0, Playlist::Column_Artist))); EXPECT_EQ(QStringLiteral("Artist"), playlist_.data(playlist_.index(0, Playlist::Column_Artist)));
EXPECT_EQ("Album", playlist_.data(playlist_.index(0, Playlist::Column_Album))); EXPECT_EQ(QStringLiteral("Album"), playlist_.data(playlist_.index(0, Playlist::Column_Album)));
EXPECT_EQ(123, playlist_.data(playlist_.index(0, Playlist::Column_Length))); EXPECT_EQ(123, playlist_.data(playlist_.index(0, Playlist::Column_Length)));
} }
TEST_F(PlaylistTest, Indexes) { 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())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
// Start "playing" track 1 // Start "playing" track 1
playlist_.set_current_row(0); playlist_.set_current_row(0);
EXPECT_EQ(0, playlist_.current_row()); 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_.previous_row());
EXPECT_EQ(1, playlist_.next_row()); EXPECT_EQ(1, playlist_.next_row());
@ -113,14 +113,14 @@ TEST_F(PlaylistTest, Indexes) {
// Play track 2 // Play track 2
playlist_.set_current_row(1); playlist_.set_current_row(1);
EXPECT_EQ(1, playlist_.current_row()); 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(0, playlist_.previous_row());
EXPECT_EQ(2, playlist_.next_row()); EXPECT_EQ(2, playlist_.next_row());
// Play track 3 // Play track 3
playlist_.set_current_row(2); playlist_.set_current_row(2);
EXPECT_EQ(2, playlist_.current_row()); 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_.previous_row());
EXPECT_EQ(-1, playlist_.next_row()); EXPECT_EQ(-1, playlist_.next_row());
@ -128,7 +128,7 @@ TEST_F(PlaylistTest, Indexes) {
TEST_F(PlaylistTest, RepeatPlaylist) { 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())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
playlist_.sequence()->SetRepeatMode(PlaylistSequence::RepeatMode::Playlist); playlist_.sequence()->SetRepeatMode(PlaylistSequence::RepeatMode::Playlist);
@ -146,7 +146,7 @@ TEST_F(PlaylistTest, RepeatPlaylist) {
TEST_F(PlaylistTest, RepeatTrack) { 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())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
playlist_.sequence()->SetRepeatMode(PlaylistSequence::RepeatMode::Track); playlist_.sequence()->SetRepeatMode(PlaylistSequence::RepeatMode::Track);
@ -159,9 +159,9 @@ TEST_F(PlaylistTest, RepeatTrack) {
TEST_F(PlaylistTest, RepeatAlbum) { TEST_F(PlaylistTest, RepeatAlbum) {
playlist_.InsertItems(PlaylistItemPtrList() playlist_.InsertItems(PlaylistItemPtrList()
<< MakeMockItemP("One", "Album one") << MakeMockItemP(QStringLiteral("One"), QStringLiteral("Album one"))
<< MakeMockItemP("Two", "Album two") << MakeMockItemP(QStringLiteral("Two"), QStringLiteral("Album two"))
<< MakeMockItemP("Three", "Album one")); << MakeMockItemP(QStringLiteral("Three"), QStringLiteral("Album one")));
ASSERT_EQ(3, playlist_.rowCount(QModelIndex())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
playlist_.sequence()->SetRepeatMode(PlaylistSequence::RepeatMode::Album); playlist_.sequence()->SetRepeatMode(PlaylistSequence::RepeatMode::Album);
@ -177,7 +177,7 @@ TEST_F(PlaylistTest, RepeatAlbum) {
TEST_F(PlaylistTest, RemoveBeforeCurrent) { TEST_F(PlaylistTest, RemoveBeforeCurrent) {
playlist_.InsertItems(PlaylistItemPtrList() playlist_.InsertItems(PlaylistItemPtrList()
<< MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three")); << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
ASSERT_EQ(3, playlist_.rowCount(QModelIndex())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
// Remove a row before the currently playing track // Remove a row before the currently playing track
@ -194,7 +194,7 @@ TEST_F(PlaylistTest, RemoveBeforeCurrent) {
TEST_F(PlaylistTest, RemoveAfterCurrent) { TEST_F(PlaylistTest, RemoveAfterCurrent) {
playlist_.InsertItems(PlaylistItemPtrList() playlist_.InsertItems(PlaylistItemPtrList()
<< MakeMockItemP("One") << MakeMockItemP("Two") << MakeMockItemP("Three")); << MakeMockItemP(QStringLiteral("One")) << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
ASSERT_EQ(3, playlist_.rowCount(QModelIndex())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
// Remove a row after the currently playing track // Remove a row after the currently playing track
@ -213,7 +213,7 @@ TEST_F(PlaylistTest, RemoveAfterCurrent) {
TEST_F(PlaylistTest, RemoveCurrent) { 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())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
// Remove the currently playing track's row // Remove the currently playing track's row
@ -229,12 +229,12 @@ TEST_F(PlaylistTest, RemoveCurrent) {
TEST_F(PlaylistTest, InsertBeforeCurrent) { 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())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
playlist_.set_current_row(1); playlist_.set_current_row(1);
EXPECT_EQ(1, playlist_.current_row()); 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())); ASSERT_EQ(4, playlist_.rowCount(QModelIndex()));
EXPECT_EQ(2, playlist_.current_row()); EXPECT_EQ(2, playlist_.current_row());
@ -242,19 +242,19 @@ TEST_F(PlaylistTest, InsertBeforeCurrent) {
EXPECT_EQ(1, playlist_.previous_row()); EXPECT_EQ(1, playlist_.previous_row());
EXPECT_EQ(3, playlist_.next_row()); EXPECT_EQ(3, playlist_.next_row());
EXPECT_EQ("Four", playlist_.data(playlist_.index(0, Playlist::Column_Title))); EXPECT_EQ(QStringLiteral("Four"), playlist_.data(playlist_.index(0, Playlist::Column_Title)));
EXPECT_EQ("One", playlist_.data(playlist_.index(1, Playlist::Column_Title))); EXPECT_EQ(QStringLiteral("One"), playlist_.data(playlist_.index(1, Playlist::Column_Title)));
} }
TEST_F(PlaylistTest, InsertAfterCurrent) { 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())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
playlist_.set_current_row(1); playlist_.set_current_row(1);
EXPECT_EQ(1, playlist_.current_row()); 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())); ASSERT_EQ(4, playlist_.rowCount(QModelIndex()));
EXPECT_EQ(1, playlist_.current_row()); EXPECT_EQ(1, playlist_.current_row());
@ -262,15 +262,15 @@ TEST_F(PlaylistTest, InsertAfterCurrent) {
EXPECT_EQ(0, playlist_.previous_row()); EXPECT_EQ(0, playlist_.previous_row());
EXPECT_EQ(2, playlist_.next_row()); EXPECT_EQ(2, playlist_.next_row());
EXPECT_EQ("Two", playlist_.data(playlist_.index(1, Playlist::Column_Title))); EXPECT_EQ(QStringLiteral("Two"), playlist_.data(playlist_.index(1, Playlist::Column_Title)));
EXPECT_EQ("Four", playlist_.data(playlist_.index(2, Playlist::Column_Title))); EXPECT_EQ(QStringLiteral("Four"), playlist_.data(playlist_.index(2, Playlist::Column_Title)));
EXPECT_EQ("Three", playlist_.data(playlist_.index(3, Playlist::Column_Title))); EXPECT_EQ(QStringLiteral("Three"), playlist_.data(playlist_.index(3, Playlist::Column_Title)));
} }
TEST_F(PlaylistTest, Clear) { 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())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
playlist_.set_current_row(1); playlist_.set_current_row(1);
@ -290,7 +290,7 @@ TEST_F(PlaylistTest, UndoAdd) {
EXPECT_FALSE(playlist_.undo_stack()->canUndo()); EXPECT_FALSE(playlist_.undo_stack()->canUndo());
EXPECT_FALSE(playlist_.undo_stack()->canRedo()); EXPECT_FALSE(playlist_.undo_stack()->canRedo());
playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Title")); playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Title")));
EXPECT_EQ(1, playlist_.rowCount(QModelIndex())); EXPECT_EQ(1, playlist_.rowCount(QModelIndex()));
EXPECT_FALSE(playlist_.undo_stack()->canRedo()); EXPECT_FALSE(playlist_.undo_stack()->canRedo());
ASSERT_TRUE(playlist_.undo_stack()->canUndo()); ASSERT_TRUE(playlist_.undo_stack()->canUndo());
@ -305,26 +305,26 @@ TEST_F(PlaylistTest, UndoAdd) {
EXPECT_FALSE(playlist_.undo_stack()->canRedo()); EXPECT_FALSE(playlist_.undo_stack()->canRedo());
EXPECT_TRUE(playlist_.undo_stack()->canUndo()); 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) { TEST_F(PlaylistTest, UndoMultiAdd) {
// Add 1 item // Add 1 item
playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("One")); playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("One")));
// Add 2 items // Add 2 items
playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Two") << MakeMockItemP("Three")); playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Two")) << MakeMockItemP(QStringLiteral("Three")));
// Undo adding 2 items // Undo adding 2 items
ASSERT_TRUE(playlist_.undo_stack()->canUndo()); 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(); playlist_.undo_stack()->undo();
// Undo adding 1 item // Undo adding 1 item
ASSERT_TRUE(playlist_.undo_stack()->canUndo()); 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(); playlist_.undo_stack()->undo();
EXPECT_FALSE(playlist_.undo_stack()->canUndo()); 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()->canUndo());
EXPECT_FALSE(playlist_.undo_stack()->canRedo()); EXPECT_FALSE(playlist_.undo_stack()->canRedo());
playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Title")); playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Title")));
EXPECT_TRUE(playlist_.undo_stack()->canUndo()); EXPECT_TRUE(playlist_.undo_stack()->canUndo());
EXPECT_FALSE(playlist_.undo_stack()->canRedo()); EXPECT_FALSE(playlist_.undo_stack()->canRedo());
@ -351,7 +351,7 @@ TEST_F(PlaylistTest, UndoRemove) {
EXPECT_EQ(1, playlist_.rowCount(QModelIndex())); EXPECT_EQ(1, playlist_.rowCount(QModelIndex()));
ASSERT_TRUE(playlist_.undo_stack()->canRedo()); 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(); playlist_.undo_stack()->redo();
EXPECT_EQ(0, playlist_.rowCount(QModelIndex())); EXPECT_EQ(0, playlist_.rowCount(QModelIndex()));
@ -363,7 +363,7 @@ TEST_F(PlaylistTest, UndoRemove) {
TEST_F(PlaylistTest, UndoMultiRemove) { TEST_F(PlaylistTest, UndoMultiRemove) {
// Add 3 items // 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())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
// Remove 1 item // Remove 1 item
@ -376,7 +376,7 @@ TEST_F(PlaylistTest, UndoMultiRemove) {
// Undo removing all 3 items // Undo removing all 3 items
ASSERT_TRUE(playlist_.undo_stack()->canUndo()); 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(); playlist_.undo_stack()->undo();
ASSERT_EQ(3, playlist_.rowCount(QModelIndex())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
@ -385,13 +385,13 @@ TEST_F(PlaylistTest, UndoMultiRemove) {
TEST_F(PlaylistTest, UndoClear) { 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())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
playlist_.Clear(); playlist_.Clear();
ASSERT_EQ(0, playlist_.rowCount(QModelIndex())); ASSERT_EQ(0, playlist_.rowCount(QModelIndex()));
ASSERT_TRUE(playlist_.undo_stack()->canUndo()); 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(); playlist_.undo_stack()->undo();
ASSERT_EQ(3, playlist_.rowCount(QModelIndex())); ASSERT_EQ(3, playlist_.rowCount(QModelIndex()));
@ -400,7 +400,7 @@ TEST_F(PlaylistTest, UndoClear) {
TEST_F(PlaylistTest, UndoRemoveCurrent) { TEST_F(PlaylistTest, UndoRemoveCurrent) {
playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Title")); playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Title")));
playlist_.set_current_row(0); playlist_.set_current_row(0);
EXPECT_EQ(0, playlist_.current_row()); EXPECT_EQ(0, playlist_.current_row());
EXPECT_EQ(0, playlist_.last_played_row()); EXPECT_EQ(0, playlist_.last_played_row());
@ -417,7 +417,7 @@ TEST_F(PlaylistTest, UndoRemoveCurrent) {
TEST_F(PlaylistTest, UndoRemoveOldCurrent) { TEST_F(PlaylistTest, UndoRemoveOldCurrent) {
playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP("Title")); playlist_.InsertItems(PlaylistItemPtrList() << MakeMockItemP(QStringLiteral("Title")));
playlist_.set_current_row(0); playlist_.set_current_row(0);
EXPECT_EQ(0, playlist_.current_row()); EXPECT_EQ(0, playlist_.current_row());
EXPECT_EQ(0, playlist_.last_played_row()); EXPECT_EQ(0, playlist_.last_played_row());
@ -440,7 +440,7 @@ TEST_F(PlaylistTest, ShuffleThenNext) {
PlaylistItemPtrList items; PlaylistItemPtrList items;
items.reserve(100); items.reserve(100);
for (int i=0 ; i<100 ; ++i) for (int i=0 ; i<100 ; ++i)
items << MakeMockItemP("Item " + QString::number(i)); items << MakeMockItemP(QStringLiteral("Item ") + QString::number(i));
playlist_.InsertItems(items); playlist_.InsertItems(items);
playlist_.set_current_row(0); playlist_.set_current_row(0);
@ -453,8 +453,8 @@ TEST_F(PlaylistTest, ShuffleThenNext) {
} }
int index = playlist_.current_row(); int index = playlist_.current_row();
EXPECT_EQ("Item 0", playlist_.current_item()->Metadata().title()); EXPECT_EQ(QStringLiteral("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_.data(playlist_.index(index, Playlist::Column_Title)));
EXPECT_EQ(index, playlist_.last_played_row()); EXPECT_EQ(index, playlist_.last_played_row());
//EXPECT_EQ(index + 1, playlist_.next_row()); //EXPECT_EQ(index + 1, playlist_.next_row());
@ -466,8 +466,8 @@ TEST_F(PlaylistTest, ShuffleThenNext) {
//} //}
index = playlist_.current_row(); index = playlist_.current_row();
EXPECT_EQ("Item 0", playlist_.current_item()->Metadata().title()); EXPECT_EQ(QStringLiteral("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_.data(playlist_.index(index, Playlist::Column_Title)));
EXPECT_EQ(index, playlist_.last_played_row()); EXPECT_EQ(index, playlist_.last_played_row());
//EXPECT_EQ(-1, playlist_.next_row()); //EXPECT_EQ(-1, playlist_.next_row());
//EXPECT_EQ(index-1, playlist_.previous_row()); //EXPECT_EQ(index-1, playlist_.previous_row());
@ -477,7 +477,7 @@ TEST_F(PlaylistTest, ShuffleThenNext) {
TEST_F(PlaylistTest, CollectionIdMapSingle) { TEST_F(PlaylistTest, CollectionIdMapSingle) {
Song song; Song song;
song.Init("title", "artist", "album", 123); song.Init(QStringLiteral("title"), QStringLiteral("artist"), QStringLiteral("album"), 123);
song.set_id(1); song.set_id(1);
PlaylistItemPtr item(std::make_shared<CollectionPlaylistItem>(song)); PlaylistItemPtr item(std::make_shared<CollectionPlaylistItem>(song));
@ -498,7 +498,7 @@ TEST_F(PlaylistTest, CollectionIdMapSingle) {
TEST_F(PlaylistTest, CollectionIdMapInvalid) { TEST_F(PlaylistTest, CollectionIdMapInvalid) {
Song invalid; Song invalid;
invalid.Init("title", "artist", "album", 123); invalid.Init(QStringLiteral("title"), QStringLiteral("artist"), QStringLiteral("album"), 123);
ASSERT_EQ(-1, invalid.id()); ASSERT_EQ(-1, invalid.id());
PlaylistItemPtr item(std::make_shared<CollectionPlaylistItem>(invalid)); PlaylistItemPtr item(std::make_shared<CollectionPlaylistItem>(invalid));
@ -514,11 +514,11 @@ TEST_F(PlaylistTest, CollectionIdMapInvalid) {
TEST_F(PlaylistTest, CollectionIdMapMulti) { TEST_F(PlaylistTest, CollectionIdMapMulti) {
Song one; Song one;
one.Init("title", "artist", "album", 123); one.Init(QStringLiteral("title"), QStringLiteral("artist"), QStringLiteral("album"), 123);
one.set_id(1); one.set_id(1);
Song two; 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); two.set_id(2);
PlaylistItemPtr item_one(std::make_shared<CollectionPlaylistItem>(one)); PlaylistItemPtr item_one(std::make_shared<CollectionPlaylistItem>(one));

10
tests/src/songplaylistitem_test.cpp
View File

@ -41,7 +41,7 @@ namespace {
class SongPlaylistItemTest : public ::testing::TestWithParam<const char*> { class SongPlaylistItemTest : public ::testing::TestWithParam<const char*> {
protected: protected:
SongPlaylistItemTest() : temp_file_(GetParam()) {} SongPlaylistItemTest() : temp_file_(QString::fromUtf8(GetParam())) {}
void SetUp() override { void SetUp() override {
// SongPlaylistItem::Url() checks if the file exists, so we need a real file // 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(); 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_)); song_.set_url(QUrl::fromLocalFile(absolute_file_name_));
item_ = make_unique<SongPlaylistItem>(song_); item_ = make_unique<SongPlaylistItem>(song_);
if (!absolute_file_name_.startsWith('/')) if (!absolute_file_name_.startsWith(QLatin1Char('/')))
absolute_file_name_.prepend('/'); absolute_file_name_.prepend(QLatin1Char('/'));
} }
Song song_; // NOLINT(cppcoreguidelines-non-private-member-variables-in-classes) 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) { TEST_P(SongPlaylistItemTest, Url) {
QUrl expected; QUrl expected;
expected.setScheme("file"); expected.setScheme(QStringLiteral("file"));
expected.setPath(absolute_file_name_); expected.setPath(absolute_file_name_);
EXPECT_EQ(expected, item_->Url()); EXPECT_EQ(expected, item_->Url());

1292
tests/src/tagreader_test.cpp
View File

File diff suppressed because it is too large Load Diff

2
tests/src/test_utils.cpp
View File

@ -62,7 +62,7 @@ void PrintTo(const ::QUrl &url, std::ostream &os) {
TemporaryResource::TemporaryResource(const QString &filename, QObject *parent) : QTemporaryFile(parent) { 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(); open();
QFile resource(filename); QFile resource(filename);

116
tests/src/utilities_test.cpp
View File

@ -38,21 +38,21 @@
TEST(UtilitiesTest, PrettyTimeDelta) { 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) { 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) { 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) { 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) { TEST(UtilitiesTest, PrettySize) {
ASSERT_EQ(Utilities::PrettySize(787200), "787.2 KB"); ASSERT_EQ(Utilities::PrettySize(787200), QStringLiteral("787.2 KB"));
} }
TEST(UtilitiesTest, ColorToRgba) { 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) { TEST(UtilitiesTest, HmacFunctions) {
QString key("key"); QString key(QStringLiteral("key"));
QString data("The quick brown fox jumps over the lazy dog"); QString data(QStringLiteral("The quick brown fox jumps over the lazy dog"));
// Test Hmac MD5 // Test Hmac MD5
QString result_hash_md5 = Utilities::HmacMd5(key.toLocal8Bit(), data.toLocal8Bit()).toHex(); QString result_hash_md5 = QString::fromLatin1(Utilities::HmacMd5(key.toLocal8Bit(), data.toLocal8Bit()).toHex());
bool result_md5 = result_hash_md5 == QString("80070713463e7749b90c2dc24911e275"); bool result_md5 = result_hash_md5 == QStringLiteral("80070713463e7749b90c2dc24911e275");
EXPECT_TRUE(result_md5); EXPECT_TRUE(result_md5);
// Test Hmac SHA256 // Test Hmac SHA256
QString result_hash_sha256 = Utilities::HmacSha256(key.toLocal8Bit(), data.toLocal8Bit()).toHex(); QString result_hash_sha256 = QString::fromLatin1(Utilities::HmacSha256(key.toLocal8Bit(), data.toLocal8Bit()).toHex());
bool result_sha256 = result_hash_sha256 == QString("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8"); bool result_sha256 = result_hash_sha256 == QStringLiteral("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8");
EXPECT_TRUE(result_sha256); EXPECT_TRUE(result_sha256);
} }
TEST(UtilitiesTest, PrettySize2) { TEST(UtilitiesTest, PrettySize2) {
ASSERT_EQ(Utilities::PrettySize(QSize(22, 32)), "22x32"); ASSERT_EQ(Utilities::PrettySize(QSize(22, 32)), QStringLiteral("22x32"));
} }
TEST(UtilitiesTest, ParseRFC822DateTime) { 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()); 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()); 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()); EXPECT_TRUE(result_DateTime.isValid());
} }
TEST(UtilitiesTest, DecodeHtmlEntities) { TEST(UtilitiesTest, DecodeHtmlEntities) {
ASSERT_EQ(Utilities::DecodeHtmlEntities("&amp;"), "&"); ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&amp;")), QStringLiteral("&"));
ASSERT_EQ(Utilities::DecodeHtmlEntities("&#38;"), "&"); ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&#38;")), QStringLiteral("&"));
ASSERT_EQ(Utilities::DecodeHtmlEntities("&quot;"), "\""); ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&quot;")), QStringLiteral("\""));
ASSERT_EQ(Utilities::DecodeHtmlEntities("&#34;"), "\""); ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&#34;")), QStringLiteral("\""));
ASSERT_EQ(Utilities::DecodeHtmlEntities("&apos;"), "'"); ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&apos;")), QStringLiteral("'"));
ASSERT_EQ(Utilities::DecodeHtmlEntities("&#39;"), "'"); ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&#39;")), QStringLiteral("'"));
ASSERT_EQ(Utilities::DecodeHtmlEntities("&lt;"), "<"); ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&lt;")), QStringLiteral("<"));
ASSERT_EQ(Utilities::DecodeHtmlEntities("&#60;"), "<"); ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&#60;")), QStringLiteral("<"));
ASSERT_EQ(Utilities::DecodeHtmlEntities("&gt;"), ">"); ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&gt;")), QStringLiteral(">"));
ASSERT_EQ(Utilities::DecodeHtmlEntities("&#62;"), ">"); ASSERT_EQ(Utilities::DecodeHtmlEntities(QStringLiteral("&#62;")), QStringLiteral(">"));
} }
TEST(UtilitiesTest, PathWithoutFilenameExtension) { 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) { 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) { TEST(UtilitiesTest, SetEnvGetEnv) {
QString var = "STRAWBERRY_UNIT_TEST_" + Utilities::GetRandomStringWithCharsAndNumbers(20); QString var = QStringLiteral("STRAWBERRY_UNIT_TEST_") + Utilities::GetRandomStringWithCharsAndNumbers(20);
QString value = "STRAWBERRY_UNIT_TEST_" + Utilities::GetRandomStringWithCharsAndNumbers(20); QString value = QStringLiteral("STRAWBERRY_UNIT_TEST_") + Utilities::GetRandomStringWithCharsAndNumbers(20);
Utilities::SetEnv(var.toUtf8().constData(), value); Utilities::SetEnv(var.toUtf8().constData(), value);
ASSERT_EQ(Utilities::GetEnv(var), 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::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) { 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_performer(Utilities::GetRandomStringWithChars(8));
song.set_grouping(Utilities::GetRandomStringWithChars(8)); song.set_grouping(Utilities::GetRandomStringWithChars(8));
song.set_length_nanosec(900000000000); 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_skipcount(20);
song.set_playcount(90); song.set_playcount(90);
song.set_rating(1.0); song.set_rating(1.0);
ASSERT_EQ(Utilities::ReplaceVariable("%title%", song, ""), song.title()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%title%"), song, QLatin1String("")), song.title());
ASSERT_EQ(Utilities::ReplaceVariable("%album%", song, ""), song.album()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%album%"), song, QLatin1String("")), song.album());
ASSERT_EQ(Utilities::ReplaceVariable("%artist%", song, ""), song.artist()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%artist%"), song, QLatin1String("")), song.artist());
ASSERT_EQ(Utilities::ReplaceVariable("%albumartist%", song, ""), song.effective_albumartist()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%albumartist%"), song, QLatin1String("")), song.effective_albumartist());
ASSERT_EQ(Utilities::ReplaceVariable("%track%", song, ""), QString::number(song.track())); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%track%"), song, QLatin1String("")), QString::number(song.track()));
ASSERT_EQ(Utilities::ReplaceVariable("%disc%", song, ""), QString::number(song.disc())); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%disc%"), song, QLatin1String("")), QString::number(song.disc()));
ASSERT_EQ(Utilities::ReplaceVariable("%year%", song, ""), QString::number(song.year())); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%year%"), song, QLatin1String("")), QString::number(song.year()));
ASSERT_EQ(Utilities::ReplaceVariable("%originalyear%", song, ""), QString::number(song.originalyear())); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%originalyear%"), song, QLatin1String("")), QString::number(song.originalyear()));
ASSERT_EQ(Utilities::ReplaceVariable("%genre%", song, ""), song.genre()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%genre%"), song, QLatin1String("")), song.genre());
ASSERT_EQ(Utilities::ReplaceVariable("%composer%", song, ""), song.composer()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%composer%"), song, QLatin1String("")), song.composer());
ASSERT_EQ(Utilities::ReplaceVariable("%performer%", song, ""), song.performer()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%performer%"), song, QLatin1String("")), song.performer());
ASSERT_EQ(Utilities::ReplaceVariable("%grouping%", song, ""), song.grouping()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%grouping%"), song, QLatin1String("")), song.grouping());
ASSERT_EQ(Utilities::ReplaceVariable("%length%", song, ""), song.PrettyLength()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%length%"), song, QLatin1String("")), song.PrettyLength());
ASSERT_EQ(Utilities::ReplaceVariable("%filename%", song, ""), song.basefilename()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%filename%"), song, QLatin1String("")), song.basefilename());
ASSERT_EQ(Utilities::ReplaceVariable("%url%", song, ""), song.url().toString()); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%url%"), song, QLatin1String("")), song.url().toString());
ASSERT_EQ(Utilities::ReplaceVariable("%playcount%", song, ""), QString::number(song.playcount())); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%playcount%"), song, QLatin1String("")), QString::number(song.playcount()));
ASSERT_EQ(Utilities::ReplaceVariable("%skipcount%", song, ""), QString::number(song.skipcount())); ASSERT_EQ(Utilities::ReplaceVariable(QStringLiteral("%skipcount%"), song, QLatin1String("")), QString::number(song.skipcount()));
ASSERT_EQ(Utilities::ReplaceVariable("%rating%", song, ""), song.PrettyRating()); 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_performer(Utilities::GetRandomStringWithChars(8));
song.set_grouping(Utilities::GetRandomStringWithChars(8)); song.set_grouping(Utilities::GetRandomStringWithChars(8));
song.set_length_nanosec(900000000000); 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_skipcount(20);
song.set_playcount(90); song.set_playcount(90);
song.set_rating(1.0); 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());
} }