void ut_load::testFileNotFound()
{
QFile fooFile("/usr/share/quillimagefilter-tests/images/fooxxx.png");
QVERIFY(!fooFile.exists());
QImage fooImage(fooFile.fileName());
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
QVERIFY(filter);
QCOMPARE(filter->name(), QString("com.meego.load"));
QVERIFY(filter->supportsOption(QuillImageFilter::FileName));
QVERIFY(filter->supportsOption(QuillImageFilter::FileFormat));
QVERIFY(filter->supportsOption(QuillImageFilter::DisableUndo));
QVERIFY(filter->supportsOption(QuillImageFilter::SizeAfter));
filter->setOption(QuillImageFilter::FileName,
QVariant(fooFile.fileName()));
filter->setOption(QuillImageFilter::MimeType,
QVariant("image/png"));
filter->apply(fooImage);
QCOMPARE(filter->error(),QuillImageFilter::FileNotFoundError);
fooFile.close();
delete filter;
}
void ut_load::testTransparency()
{
QTemporaryFile testFile;
testFile.open();
QImage image = Unittests::generatePaletteImage();
image = image.convertToFormat(QImage::Format_ARGB32);
image.setPixel(QPoint(0, 0), qRgba(255, 0, 0, 0));
image.setPixel(QPoint(0, 1), qRgba(255, 0, 0, 127));
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
filter->setOption(QuillImageFilter::FileName, testFile.fileName());
filter->setOption(QuillImageFilter::FileFormat, QString("png"));
filter->setOption(QuillImageFilter::BackgroundColor, QColor(qRgb(0, 0, 255)));
QuillImage imageAfter = filter->apply(image);
QCOMPARE(imageAfter.pixel(QPoint(0, 0)), qRgb(0, 0, 255));
QCOMPARE(imageAfter.pixel(QPoint(0, 1)), qRgb(127, 0, 128));
delete filter;
}
void ut_load::testLoadSameFilterTwice()
{
QTemporaryFile testFile;
testFile.open();
QImage greenTestImage("/usr/share/quillimagefilter-tests/images/854x480_blue.png");
// Verify whether image exists
QVERIFY(!greenTestImage.isNull());
greenTestImage.save(testFile.fileName(), "jpg");
QuillImage target = QuillImage();
target.setFullImageSize(QSize(854, 480));
target.setArea(QRect(0, 0, 854, 480));
QuillImage target2 = QuillImage();
target2.setFullImageSize(QSize(854, 480));
target2.setArea(QRect(0, 0, 854, 480));
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
filter->setOption(QuillImageFilter::FileName, testFile.fileName());
// Passing JPEG through the filter
QuillImage imageAfter = filter->apply(target);
// Passing JPEG through the filter
QuillImage imageAfter2 = filter->apply(target2);
// Checking the red channel value which should be always bigger than that of greeen channel
QVERIFY( qBlue(imageAfter.pixel(QPoint(0, 0))) > qGreen(imageAfter.pixel(QPoint(0, 0))) );
// Checking the red channel value which should be always bigger than that of greeen channel
QVERIFY( qBlue(imageAfter2.pixel(QPoint(0, 0))) > qGreen(imageAfter2.pixel(QPoint(0, 0))) );
delete filter;
}
void ut_flip::testQuillImage()
{
QuillImage image(Unittests::generatePaletteImage());
image.setFullImageSize(QSize(16, 4));
image.setArea(QRect(0, 0, 8, 2));
QuillImageFilter *filter = new QuillImageFilter("org.maemo.flip");
QVERIFY(filter->isValid());
// Flip vertical
QuillImage image2 = filter->apply(image);
QCOMPARE((QImage)image2, image.mirrored(false, true));
QCOMPARE(image2.fullImageSize(), QSize(16, 4));
QCOMPARE(image2.area(), QRect(0, 2, 8,2));
// Flip horizontal
filter->setOption(QuillImageFilter::Horizontal, true);
QuillImage image3 = filter->apply(image2);
QCOMPARE((QImage)image3, image.mirrored(true, true));
QCOMPARE(image3.fullImageSize(), QSize(16, 4));
QCOMPARE(image3.area(), QRect(8, 2, 8, 2));
delete filter;
}
void ut_croppedthumbnail::testCroppedThumbnailAfterEdit()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
Quill::setPreviewLevelCount(1);
Quill::setPreviewSize(0, QSize(2, 2));
Quill::setMinimumPreviewSize(0, QSize(2, 2));
QuillFile *file = new QuillFile(testFile.fileName());
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_Crop);
filter->setOption(QuillImageFilter::CropRectangle, QRect(0, 0, 4, 2));
file->runFilter(filter);
file->setDisplayLevel(1);
Quill::releaseAndWait(); // load 0
Quill::releaseAndWait(); // crop 0 - bad version
Quill::releaseAndWait(); // load 1
Quill::releaseAndWait(); // crop 1
Quill::releaseAndWait(); // reform 0
file->setDisplayLevel(0);
QCOMPARE(file->allImageLevels().count(), 1);
QCOMPARE(file->allImageLevels().first().size(), QSize(2, 2));
QVERIFY(Unittests::compareImage(file->allImageLevels().first(),
image.copy(1, 0, 2, 2)));
delete file;
}
void ut_file::testEdittingHistory()
{
QTemporaryFile testFile1;
testFile1.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile1.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillFile *file = new QuillFile(testFile1.fileName(), Strings::png);
File *fileObject = file->internalFile();
QVERIFY(file->setDisplayLevel(0));
QVERIFY(!fileObject->hasOriginal());
QFile editHistory(fileObject->editHistoryFileName(fileObject->fileName(),
Core::instance()->editHistoryPath()));
QVERIFY(!editHistory.exists());
file->runFilter(filter);
file->undo();
QVERIFY(editHistory.exists());
QVERIFY(!fileObject->hasOriginal());
}
void ut_stack::testDropRedoHistory()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage resultImage = filter->apply(image);
QuillImageFilter *filter2 =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter2->setOption(QuillImageFilter::Contrast, QVariant(20));
QuillImage resultImage2 = filter2->apply(resultImage);
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
file->runFilter(filter);
file->runFilter(filter2);
file->undo();
QVERIFY(file->canRedo());
file->dropRedoHistory();
QVERIFY(!file->canRedo());
delete file;
}
void ut_file::testDifferentPreviewLevels()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage imageAfter = filter->apply(image);
Quill::setPreviewSize(0, QSize(4, 1));
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QuillFile *file2 = new QuillFile(testFile.fileName(), Strings::png);
QSignalSpy spy(file, SIGNAL(imageAvailable(const QuillImageList)));
QSignalSpy spy2(file2, SIGNAL(imageAvailable(const QuillImageList)));
QVERIFY(file != file2);
QVERIFY(file2->setDisplayLevel(1));
QVERIFY(file->setDisplayLevel(0));
file->runFilter(filter);
Quill::releaseAndWait(); // load level 0
Quill::releaseAndWait(); // brightness level 0
QCOMPARE(spy.count(), 1);
QCOMPARE(spy2.count(), 1);
QCOMPARE(file->image().size(), QSize(4, 1));
QCOMPARE(file->image().z(), 0);
QCOMPARE(file2->image().size(), QSize(4, 1));
QCOMPARE(file2->image().z(), 0);
Quill::releaseAndWait(); // load level 1
Quill::releaseAndWait(); // brightness level 1
QCOMPARE(spy.count(), 1);
QCOMPARE(spy2.count(), 2);
QCOMPARE(file->image().size(), QSize(4, 1));
QCOMPARE(file->image().z(), 0);
QVERIFY(Unittests::compareImage(file2->image(), imageAfter));
QCOMPARE(file2->image().z(), 1);
delete file2;
// Ensure that the display level is kept even if the other image reference
// is removed.
QCOMPARE(file->image().size(), QSize(4, 1));
QCOMPARE(file->image().z(), 0);
delete file;
}
void ut_file::testDoubleRevertRestore()
{
// Tests that revert and restore still work after a previous revert.
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImageFilter *filter2 =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter2);
filter2->setOption(QuillImageFilter::Brightness, QVariant(-20));
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
file->runFilter(filter);
QVERIFY(file->canRevert());
file->revert();
QVERIFY(file->canRestore());
file->runFilter(filter2);
QVERIFY(file->canRevert());
file->revert();
QVERIFY(file->canRestore());
delete file;
}
void ut_scale::testScalePreview()
{
// No changes must be made to a preview image
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.scale");
QVERIFY(filter);
QVERIFY(filter->setOption(QuillImageFilter::SizeAfter, QSize(4, 1)));
QuillImage image = Unittests::generatePaletteImage();
QCOMPARE(image.size(), QSize(8, 2));
image.setFullImageSize(QSize(16, 4));
image.setArea(QRect(0, 0, 16, 4));
QuillImage image2 = filter->apply(image);
QCOMPARE(image2.size(), QSize(8, 2));
QCOMPARE(image2.fullImageSize(), QSize(4, 1));
QCOMPARE(image2.area(), QRect(0, 0, 4, 1));
QVERIFY(Unittests::compareImage(image, image2));
delete filter;
}
void ut_file::testOriginalAfterSave()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QuillFile *original = file->original();
// This makes us to setup the original's undo stack
QCOMPARE(original->fullImageSize(), image.size());
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage processedImage = filter->apply(image);
file->runFilter(filter);
file->save();
Quill::releaseAndWait();
Quill::releaseAndWait();
Quill::releaseAndWait();
original->setDisplayLevel(0);
Quill::releaseAndWait();
QVERIFY(Unittests::compareImage(original->image(), image));
delete file;
delete original;
}
void ut_load::testRoleAndDomainName()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Role_Load);
QVERIFY(filter);
QCOMPARE(filter->name(), QString("com.meego.load"));
delete filter;
}
void ut_scale::testRoleAndDomainName()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.scale");
QVERIFY(filter);
QCOMPARE(filter->name(), QString("com.meego.scale"));
delete filter;
}
void ut_load::testFormatDetectionFromSuffix()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
QFile file("/usr/share/quillimagefilter-tests/images/16_color_palette.png");
filter->setOption(QuillImageFilter::FileName, QString(file.fileName()));
QCOMPARE(filter->option(QuillImageFilter::FileFormat).toString(), QString("png"));
QCOMPARE(filter->option(QuillImageFilter::MimeType).toString(), QString("image/png"));
delete filter;
}
void ut_redeyereduction::testReductTwoAreas()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.red-eye-reduction");
QVERIFY(filter);
QCOMPARE(filter->name(), QString("com.meego.red-eye-reduction"));
QVariantList centerPoints;
for (int i = 100; i <= 160; i+=60)
centerPoints << QPoint(i, i);
QVERIFY(filter->setOption(QuillImageFilter::Center, QVariant(centerPoints)));
QVariantList radii;
for (int r = 10; r <= 40; r+=30)
radii << QVariant(r);
QVERIFY(filter->setOption(QuillImageFilter::Radius, QVariant(radii)));
QImage image("/usr/share/quillimagefilter-tests/images/redeye.jpg");
QVERIFY(!image.isNull());
QImage image1 = filter->apply(image);
bool bIsReduced = false;
for(int h=95; h<105; h++) {
for(int v =95; v<105; v++) {
QRgb color = image.pixel(QPoint(h, v));
int limit = (qGreen(color) + qBlue(color)) * 2 / 3;
if (qRed(color) > limit) {
QVERIFY(qRed(image.pixel(QPoint(h,v))) > (qRed(image1.pixel(QPoint(h,v)))));
bIsReduced = true;
}
}
}
QVERIFY(bIsReduced);
bIsReduced = false;
for(int h=145; h<175; h++) {
for(int v =145; v<175; v++) {
QRgb color = image.pixel(QPoint(h, v));
int limit = (qGreen(color) + qBlue(color)) * 2 / 3;
if (qRed(color) > limit) {
QVERIFY(qRed(image.pixel(QPoint(h,v))) > (qRed(image1.pixel(QPoint(h,v)))));
bIsReduced = true;
}
}
}
QVERIFY(bIsReduced);
delete filter;
}
void ut_rotate::testRotateFilter()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.rotate");
QVERIFY(filter);
QVERIFY(filter->supportsOption(QuillImageFilter::Angle));
QVERIFY(filter->setOption(QuillImageFilter::Angle, QVariant(90)));
bool bOK = true;
QCOMPARE(filter->option(QuillImageFilter::Angle).toDouble(&bOK), 90.0);
QVERIFY(bOK);
QuillImage image = Unittests::generatePaletteImage();
QCOMPARE(image.size(), QSize(8, 2));
QuillImage filteredImage = filter->apply(image);
QCOMPARE(filteredImage.size(), QSize(2, 8));
// Get reference image with QImage::transformed()
QuillImage compareToQImage = image.transformed(QTransform().rotate(90));
QCOMPARE(filteredImage, compareToQImage);
// Four rotates should produce the original image
QCOMPARE(filter->apply(filter->apply(filter->apply(filteredImage))),
image);
delete filter;
}
void ut_stack::testEditAfterSetImage()
{
QString fileName = "/tmp/quill/pctest.png";
QFile::remove(fileName);
QVERIFY(!QFile::exists(fileName));
QTemporaryFile testFile;
testFile.open();
QImage image = Unittests::generatePaletteImage();
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage resultImage = filter->apply(image);
Quill::setEditHistoryPath("/tmp/quill/history");
Quill::setEditHistoryCacheSize(0, 2);
QuillFile *file = new QuillFile(fileName, Strings::pngMimeType);
file->setDisplayLevel(0);
QuillImage quillImage(image);
quillImage.setFullImageSize(QSize(8, 2));
file->setImage(0, quillImage);
QVERIFY(Unittests::compareImage(file->image(), image));
QCOMPARE(file->fullImageSize(), QSize(8, 2));
file->runFilter(filter);
Quill::releaseAndWait();
QVERIFY(Unittests::compareImage(file->image(), resultImage));
image.save(fileName, "png");
file->refresh();
Quill::releaseAndWait(); // edit (recreate)
QVERIFY(Unittests::compareImage(file->image(), resultImage));
file->save();
Quill::releaseAndWait(); // load
Quill::releaseAndWait(); // edit
Quill::releaseAndWait(); // save
QVERIFY(Unittests::compareImage(QImage(fileName), resultImage));
delete file;
}
void ut_load:: testInvalidData()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
QFile invalidFile("/usr/share/quillimagefilter-tests/images/16_color_palette.xcf");
QImage invalidImage(invalidFile.fileName());
filter->setOption(QuillImageFilter::FileName,
QVariant( invalidFile.fileName()));
filter->setOption(QuillImageFilter::MimeType,
QVariant("image/png"));
filter->apply(invalidImage);
QCOMPARE(filter->error(),QuillImageFilter::InvalidDataError);
invalidFile.close();
delete filter;
}
void ut_load::testUnsupportedFormat()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
QFile unsupportedFile("/usr/share/quillimagefilter-tests/images/16_color_palette.xcf");
QImage unsupportedImage(unsupportedFile.fileName());
filter->setOption(QuillImageFilter::FileName,
QVariant( unsupportedFile.fileName()));
filter->setOption(QuillImageFilter::FileFormat,
QVariant("xcf"));
filter->apply(unsupportedImage);
QCOMPARE(filter->error(),QuillImageFilter::UnsupportedFormatError);
unsupportedFile.close();
delete filter;
}
void ut_load::testFormatDetectionFromContents()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
QTemporaryFile testFile;
testFile.open();
Unittests::generatePaletteImage().save(testFile.fileName(), "jpg");
filter->setOption(QuillImageFilter::FileName, QString(testFile.fileName()));
QCOMPARE(filter->option(QuillImageFilter::FileFormat).toString(), QString("jpeg"));
QCOMPARE(filter->option(QuillImageFilter::MimeType).toString(), QString("image/jpeg"));
delete filter;
}
void ut_load::testIODevice()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
QFile *fileIO = new QFile("/usr/share/quillimagefilter-tests/images/16_color_palette.png");
QVERIFY(fileIO->open(QIODevice::ReadOnly));
QCOMPARE(fileIO->isOpen(),true);
QCOMPARE(fileIO->isReadable(),true);
QVERIFY(fileIO);
filter->setIODevice(fileIO);
QCOMPARE(fileIO, filter->iODevice());
QImage image("/usr/share/quillimagefilter-tests/images/16_color_palette.png");
QImage loadedImage1 = filter->apply(image);
QVERIFY(Unittests::compareImage(loadedImage1, image));
delete fileIO;
delete filter;
}
void ut_scale::testScaleFilter()
{
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.scale");
QVERIFY(filter);
QVERIFY(filter->supportsOption(QuillImageFilter::SizeAfter));
// Assuming full image, rescaling to half size
QVERIFY(filter->setOption(QuillImageFilter::SizeAfter, QSize(4, 1)));
QCOMPARE(filter->option(QuillImageFilter::SizeAfter),
QVariant(QSize(4, 1)));
QImage image = Unittests::generatePaletteImage();
QCOMPARE(image.size(), QSize(8, 2));
QImage filteredImage = filter->apply(image);
QCOMPARE(filteredImage, image.scaled(QSize(4, 1), Qt::IgnoreAspectRatio,
Qt::SmoothTransformation));
// full image, rescaling to different aspect ratio
QVERIFY(filter->setOption(QuillImageFilter::SizeAfter, QSize(2, 8)));
filteredImage = filter->apply(image);
QCOMPARE(filteredImage, image.scaled(QSize(2, 8), Qt::IgnoreAspectRatio,
Qt::SmoothTransformation));
delete filter;
}
void ut_file::testMultipleAccess()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage imageAfter = filter->apply(image);
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QuillFile *file2 = new QuillFile(testFile.fileName(), Strings::png);
QVERIFY(file != file2);
QVERIFY(file->setDisplayLevel(0));
QVERIFY(file2->setDisplayLevel(0));
file->runFilter(filter);
Quill::releaseAndWait();
Quill::releaseAndWait();
QVERIFY(Unittests::compareImage(file->image(), imageAfter));
QVERIFY(Unittests::compareImage(file2->image(), imageAfter));
file2->undo();
Quill::releaseAndWait();
QVERIFY(Unittests::compareImage(file->image(), image));
QVERIFY(Unittests::compareImage(file2->image(), image));
delete file2;
file->redo();
Quill::releaseAndWait();
QVERIFY(Unittests::compareImage(file->image(), imageAfter));
delete file;
}
void ut_stack::testSessionSetup()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImageFilter *filter2 =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Contrast, QVariant(20));
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
file->runFilter(filter);
file->runFilter(filter2);
file->undo();
QVERIFY(!file->isSession());
QVERIFY(file->canUndo());
QVERIFY(file->canRedo());
file->startSession();
// We are in a session now, cannot undo or redo
QVERIFY(file->isSession());
QVERIFY(!file->canUndo());
QVERIFY(!file->canRedo());
// If we end the session now, we should still be able to undo and redo
file->endSession();
QVERIFY(!file->isSession());
QVERIFY(file->canUndo());
QVERIFY(file->canRedo());
delete file;
}
// Flip + flip + rotate 180 should result in original.
void ut_flip::testFlipRotate()
{
QuillImageFilter *flip = new QuillImageFilter("org.maemo.flip");
QuillImageFilter *flip2 = new QuillImageFilter("org.maemo.flip");
flip2->setOption(QuillImageFilter::Horizontal, QVariant(true));
QuillImageFilter *rotate = new QuillImageFilter("org.maemo.rotate");
rotate->setOption(QuillImageFilter::Angle, QVariant(180));
QuillImage image = Unittests::generatePaletteImage();
QCOMPARE(image, rotate->apply(flip2->apply(flip->apply(image))));
delete flip;
delete flip2;
delete rotate;
}
void ut_file::testSaveAfterDelete()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage imageAfter = filter->apply(image);
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
file->runFilter(filter);
QVERIFY(!Quill::isSaveInProgress());
QVERIFY(!file->isSaveInProgress());
file->save();
QVERIFY(Quill::isSaveInProgress());
QVERIFY(file->isSaveInProgress());
delete file;
QVERIFY(Quill::isSaveInProgress());
Quill::releaseAndWait(); // load
QVERIFY(Quill::isSaveInProgress());
Quill::releaseAndWait(); // b/c
QVERIFY(Quill::isSaveInProgress());
Quill::releaseAndWait(); // save
QVERIFY(!Quill::isSaveInProgress());
Unittests::compareImage(QImage(testFile.fileName()), imageAfter);
}
void ut_file::testOriginal()
{
QTemporaryFile testFile;
testFile.open();
QuillImage image = Unittests::generatePaletteImage();
image.save(testFile.fileName(), "png");
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
QuillImage processedImage = filter->apply(image);
file->runFilter(filter);
QuillFile *original = file->original();
QCOMPARE(file->fileName(), original->fileName());
QCOMPARE(file->originalFileName(), original->originalFileName());
QVERIFY(file->canUndo());
QVERIFY(!original->canUndo());
file->setDisplayLevel(0);
Quill::releaseAndWait();
Quill::releaseAndWait();
original->setDisplayLevel(0);
Quill::releaseAndWait();
QCOMPARE(file->image(), processedImage);
QCOMPARE(original->image(), image);
file->remove();
QVERIFY(!file->exists());
QVERIFY(!original->exists());
delete file;
delete original;
}
void ut_load::testExifRotationSizePeek()
{
QTemporaryFile testFile;
testFile.open();
QImage image("/usr/share/quillimagefilter-tests/images/16_color_palette.png");
image.save(testFile.fileName(), "jpeg");
QuillMetadata metadata;
metadata.setEntry(QuillMetadata::Tag_Orientation, QVariant(6));
metadata.write(testFile.fileName());
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.load");
filter->setOption(QuillImageFilter::FileName, QString(testFile.fileName()));
QCOMPARE(filter->newFullImageSize(QSize()), QSize(2, 8));
delete filter;
}
void ut_file::testRemove()
{
QTemporaryFile testFile;
testFile.open();
Unittests::generatePaletteImage().save(testFile.fileName(), "png");
QSignalSpy spy(Quill::instance(),
SIGNAL(removed(const QString)));
QuillFile *file = new QuillFile(testFile.fileName(), Strings::png);
QVERIFY(file);
QVERIFY(file->exists());
QString originalFileName = file->originalFileName();
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter(QuillImageFilter::Name_BrightnessContrast);
QVERIFY(filter);
filter->setOption(QuillImageFilter::Brightness, QVariant(20));
file->runFilter(filter);
file->save();
Quill::releaseAndWait(); // for runFilter()
file->remove();
QVERIFY(!file->exists());
QVERIFY(!QFile::exists(testFile.fileName()));
QVERIFY(!QFile::exists(originalFileName));
Quill::releaseAndWait(); // for save()
QVERIFY(!file->exists());
QVERIFY(!QFile::exists(testFile.fileName()));
QVERIFY(!QFile::exists(originalFileName));
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.first().first().toString(), testFile.fileName());
delete file;
}
void ut_crop::testPreview()
{
// full is 8x2, preview is 4x1, apply crop to preview
QuillImageFilter *filter =
QuillImageFilterFactory::createImageFilter("org.maemo.crop");
QVERIFY(filter->setOption(QuillImageFilter::CropRectangle,
QRect(QPoint(2, 0), QPoint(7, 1))));
QuillImage image(Unittests::generatePaletteImage().scaled(QSize(4,1)));
image.setFullImageSize(QSize(8, 2));
image.setArea(QRect(0, 0, 8, 2));
QuillImage filteredImage = filter->apply(image);
QCOMPARE((QImage)filteredImage, image.copy(1, 0, 3, 1));
delete filter;
}
