int main ()
{
QLinkedList<int> myQLinkedList;
myQLinkedList.push_back(77);
myQLinkedList.push_back(22);
assert(myQLinkedList.first() != 77);
// now front equals 77, and back 22
myQLinkedList.first() -= myQLinkedList.back();
assert(myQLinkedList.first() == 55);
cout << "myQLinkedList.front() is now " << myQLinkedList.first() << endl;
return 0;
}
int main ()
{
QLinkedList<QString> list;
list.prepend("one");
list.prepend("two");
list.prepend("three");
assert(list.first() == "three");
// list: ["three", "two", "one"]
return 0;
}
void tst_ExceptionSafety::exceptionLinkedList() {
{
QLinkedList<FlexibleThrowerSmall> list;
QLinkedList<FlexibleThrowerSmall> list2;
QLinkedList<FlexibleThrowerSmall> list3;
for( int i = 0; i<10; i++ )
list.append( FlexibleThrowerSmall(i) );
try {
throwType = ThrowAtCopy;
list.append( FlexibleThrowerSmall(10));
} catch (...) {
}
QCOMPARE( list.size(), 10 );
try {
throwType = ThrowAtCopy;
list.prepend( FlexibleThrowerSmall(10));
} catch (...) {
}
QCOMPARE( list.first().value(), 0 );
QCOMPARE( list.size(), 10 );
try {
throwType = ThrowAtCopy;
list3 = list;
list3.append( FlexibleThrowerSmall(11) );
} catch (...) {
}
QCOMPARE( list.first().value(), 0 );
QCOMPARE( list.size(), 10 );
QCOMPARE( list3.size(), 10 );
}
QCOMPARE(objCounter, 0 ); // check that every object has been freed
}
void SendDataThread::run()
{
while(true)
{
QMutexLocker locker(&m_DataMutex);
m_DataCondition.wait(&m_DataMutex);
int count = m_DataList.count();
for(int i = 0; i < count; ++i)
{
const QByteArray& data = m_DataList.first();
if(!::sendData(m_Socket, data.data(), data.size()))
{
qDebug()<<"Send data to server error";
return;
}
m_DataList.pop_front();
}
}
}
TEST_F(CoverArtUtilTest, searchImage) {
// creating a temp track directory
QString trackdir(QDir::tempPath() % "/TrackDir");
ASSERT_FALSE(QDir().exists(trackdir)); // it must start empty
ASSERT_TRUE(QDir().mkpath(trackdir));
TrackPointer pTrack(Track::newTemporary(kTrackLocationTest));
SoundSourceProxy(pTrack).loadTrackMetadata();
QLinkedList<QFileInfo> covers;
CoverArt res;
// looking for cover in an empty directory
res = CoverArtUtils::selectCoverArtForTrack(pTrack.data(), covers);
CoverArt expected;
expected.info.source = CoverInfo::GUESSED;
EXPECT_EQ(expected, res);
// Looking for a track with embedded cover.
pTrack = TrackPointer(Track::newTemporary(kTrackLocationTest));
SoundSourceProxy(pTrack).loadTrackMetadataAndCoverArt();
expected = CoverArt();
expected.image = pTrack->getCoverArt().image;
expected.info.type = CoverInfo::METADATA;
expected.info.source = CoverInfo::GUESSED;
expected.info.coverLocation = QString();
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
EXPECT_EQ(expected, pTrack->getCoverArt());
const char* format("jpg");
const QString qFormat(format);
// Since we already parsed this image from the matadata in
// kTrackLocationTest, hang on to it since we use it as a template for
// stuff below.
const QImage img = expected.image;
QString trackBaseName = "cover-test";
QString trackAlbum = "album_name";
// Search Strategy
// 0. If we have just one file, we will get it.
// 1. %track-file-base%.jpg in the track directory for %track-file-base%.mp3
// 2. %album%.jpg
// 3. cover.jpg
// 4. front.jpg
// 5. album.jpg
// 6. folder.jpg
// 7. if just one file exists take that otherwise none.
// All the following expect the same image/hash to be selected.
expected.image = img;
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
// All the following expect FILE and GUESSED.
expected.info.type = CoverInfo::FILE;
expected.info.source = CoverInfo::GUESSED;
// 0. saving just one cover in our temp track dir
QString cLoc_foo = QString(trackdir % "/" % "foo." % qFormat);
EXPECT_TRUE(img.save(cLoc_foo, format));
// looking for cover in an directory with one image will select that one.
expected.image = QImage(cLoc_foo);
expected.info.coverLocation = "foo.jpg";
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
covers << QFileInfo(cLoc_foo);
res = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
covers);
EXPECT_EQ(expected, res);
QFile::remove(cLoc_foo);
QStringList extraCovers;
// adding some extra images (bigger) just to populate the track dir.
QString cLoc_big1 = QString(trackdir % "/" % "big1." % qFormat);
EXPECT_TRUE(img.scaled(1000,1000).save(cLoc_big1, format));
extraCovers << cLoc_big1;
QString cLoc_big2 = QString(trackdir % "/" % "big2." % qFormat);
EXPECT_TRUE(img.scaled(900,900).save(cLoc_big2, format));
extraCovers << cLoc_big2;
QString cLoc_big3 = QString(trackdir % "/" % "big3." % qFormat);
EXPECT_TRUE(img.scaled(800,800).save(cLoc_big3, format));
extraCovers << cLoc_big3;
// saving more covers using the preferred names in the right order
QLinkedList<QFileInfo> prefCovers;
// 1. track_filename.jpg
QString cLoc_filename = QString(trackdir % "/cover-test." % qFormat);
EXPECT_TRUE(img.scaled(500,500).save(cLoc_filename, format));
prefCovers << QFileInfo(cLoc_filename);
// 2. album_name.jpg
QString cLoc_albumName = QString(trackdir % "/album_name." % qFormat);
EXPECT_TRUE(img.scaled(500,500).save(cLoc_albumName, format));
prefCovers << QFileInfo(cLoc_albumName);
// 3. cover.jpg
QString cLoc_cover = QString(trackdir % "/" % "cover." % qFormat);
EXPECT_TRUE(img.scaled(400,400).save(cLoc_cover, format));
prefCovers << QFileInfo(cLoc_cover);
// 4. front.jpg
QString cLoc_front = QString(trackdir % "/" % "front." % qFormat);
EXPECT_TRUE(img.scaled(300,300).save(cLoc_front, format));
prefCovers << QFileInfo(cLoc_front);
// 5. album.jpg
QString cLoc_album = QString(trackdir % "/" % "album." % qFormat);
EXPECT_TRUE(img.scaled(100,100).save(cLoc_album, format));
prefCovers << QFileInfo(cLoc_album);
// 6. folder.jpg
QString cLoc_folder = QString(trackdir % "/" % "folder." % qFormat);
EXPECT_TRUE(img.scaled(100,100).save(cLoc_folder, format));
prefCovers << QFileInfo(cLoc_folder);
// 8. other1.jpg
QString cLoc_other1 = QString(trackdir % "/" % "other1." % qFormat);
EXPECT_TRUE(img.scaled(10,10).save(cLoc_other1, format));
prefCovers << QFileInfo(cLoc_other1);
// 7. other2.jpg
QString cLoc_other2 = QString(trackdir % "/" % "other2." % qFormat);
EXPECT_TRUE(img.scaled(10,10).save(cLoc_other2, format));
prefCovers << QFileInfo(cLoc_other2);
// we must find covers in the right order
EXPECT_EQ(8, prefCovers.size());
// Remove the covers one by one from the front, checking that each one is
// selected as we remove the previously-most-preferable cover.
while (!prefCovers.isEmpty()) {
QFileInfo cover = prefCovers.first();
// We expect no cover selected for other1 since there are 2 covers,
// neither of which match our preferred cover names. other2 will be
// selected once we get to it since it is the only cover available.
if (cover.baseName() == "other1") {
expected.image = QImage();
expected.info.type = CoverInfo::NONE;
expected.info.coverLocation = QString();
expected.info.hash = 0;
} else {
expected.image = QImage(cover.filePath());
expected.info.type = CoverInfo::FILE;
expected.info.coverLocation = cover.fileName();
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
}
res = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
prefCovers);
EXPECT_QSTRING_EQ(expected.info.coverLocation, res.info.coverLocation);
EXPECT_QSTRING_EQ(expected.info.hash, res.info.hash);
EXPECT_EQ(expected, res);
QFile::remove(cover.filePath());
prefCovers.pop_front();
}
//
// Additional tests
//
// what is chosen when cover.jpg and cover.JPG exists?
// (it must always prefer the lighter cover)
QString cLoc_coverJPG = trackdir % "/" % "cover." % "JPG";
EXPECT_TRUE(img.scaled(200,200).save(cLoc_coverJPG, "JPG"));
prefCovers.append(QFileInfo(cLoc_coverJPG));
QString cLoc_coverjpg = trackdir % "/" % "cover." % "jpg";
EXPECT_TRUE(img.scaled(400,400).save(cLoc_coverjpg, "jpg"));
prefCovers.append(QFileInfo(cLoc_coverjpg));
extraCovers << cLoc_coverJPG << cLoc_coverjpg;
res = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
prefCovers);
expected.image = QImage(cLoc_coverJPG);
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
expected.info.coverLocation = "cover.JPG";
EXPECT_EQ(expected, res);
// As we are looking for %album%.jpg and %base_track.jpg%,
// we need to check if everything works with UTF8 chars.
trackBaseName = QString::fromUtf8("track_ðÑöæäî");
trackAlbum = QString::fromUtf8("öæäîðÑ_album");
prefCovers.clear();
// 2. album_name.jpg
cLoc_albumName = QString(trackdir % "/" % trackAlbum % "." % qFormat);
EXPECT_TRUE(img.save(cLoc_albumName, format));
prefCovers.append(QFileInfo(cLoc_albumName));
res = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
prefCovers);
expected.image = QImage(cLoc_albumName);
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
expected.info.coverLocation = trackAlbum % ".jpg";
EXPECT_EQ(expected, res);
// 1. track_filename.jpg
cLoc_filename = QString(trackdir % "/" % trackBaseName % "." % qFormat);
EXPECT_TRUE(img.save(cLoc_filename, format));
prefCovers.append(QFileInfo(cLoc_filename));
res = CoverArtUtils::selectCoverArtForTrack(trackBaseName, trackAlbum,
prefCovers);
expected.image = QImage(cLoc_filename);
expected.info.hash = CoverArtUtils::calculateHash(expected.image);
expected.info.coverLocation = trackBaseName % ".jpg";
EXPECT_EQ(expected, res);
QFile::remove(cLoc_filename);
QFile::remove(cLoc_albumName);
// cleaning temp dir
foreach (QString loc, extraCovers) {
QFile::remove(loc);
}
//static
CoverArt CoverArtUtils::selectCoverArtForTrack(
const QString& trackBaseName,
const QString& albumName,
const QLinkedList<QFileInfo>& covers) {
CoverArt art;
art.info.source = CoverInfo::GUESSED;
if (covers.isEmpty()) {
return art;
}
PreferredCoverType bestType = NONE;
const QFileInfo* bestInfo = NULL;
// If there is a single image then we use it unconditionally. Otherwise
// we use the priority order described in PreferredCoverType. Notably,
// if there are multiple image files in the folder we require they match
// one of the name patterns -- otherwise we run the risk of picking an
// arbitrary image that happens to be in the same folder as some of the
// user's music files.
if (covers.size() == 1) {
bestInfo = &covers.first();
} else {
// TODO(XXX) Sort instead so that we can fall-back if one fails to
// open?
foreach (const QFileInfo& file, covers) {
const QString coverBaseName = file.baseName();
if (bestType > TRACK_BASENAME &&
coverBaseName.compare(trackBaseName,
Qt::CaseInsensitive) == 0) {
bestType = TRACK_BASENAME;
bestInfo = &file;
// This is the best type so we know we're done.
break;
} else if (bestType > ALBUM_NAME &&
coverBaseName.compare(albumName,
Qt::CaseInsensitive) == 0) {
bestType = ALBUM_NAME;
bestInfo = &file;
} else if (bestType > COVER &&
coverBaseName.compare(QLatin1String("cover"),
Qt::CaseInsensitive) == 0) {
bestType = COVER;
bestInfo = &file;
} else if (bestType > FRONT &&
coverBaseName.compare(QLatin1String("front"),
Qt::CaseInsensitive) == 0) {
bestType = FRONT;
bestInfo = &file;
} else if (bestType > ALBUM &&
coverBaseName.compare(QLatin1String("album"),
Qt::CaseInsensitive) == 0) {
bestType = ALBUM;
bestInfo = &file;
} else if (bestType > FOLDER &&
coverBaseName.compare(QLatin1String("folder"),
Qt::CaseInsensitive) == 0) {
bestType = FOLDER;
bestInfo = &file;
}
}
}
if (bestInfo != NULL) {
art.image = QImage(bestInfo->filePath());
if (!art.image.isNull()) {
art.info.source = CoverInfo::GUESSED;
art.info.type = CoverInfo::FILE;
// TODO() here we may introduce a duplicate hash code
art.info.hash = CoverArtUtils::calculateHash(art.image);
art.info.coverLocation = bestInfo->fileName();
return art;
}
}
return art;
}