Update copyright year in Digia's license headers
[qt:qtgraphicaleffects.git] / tests / system / auto / tst_imagecompare.cpp
1 /****************************************************************************
2 **
3 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
5 **
6 ** This file is part of the Qt Graphical Effects module.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia.  For licensing terms and
14 ** conditions see http://qt.digia.com/licensing.  For further information
15 ** use the contact form at http://qt.digia.com/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file.  Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 **
25 ** In addition, as a special exception, Digia gives you certain additional
26 ** rights.  These rights are described in the Digia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28 **
29 ** GNU General Public License Usage
30 ** Alternatively, this file may be used under the terms of the GNU
31 ** General Public License version 3.0 as published by the Free Software
32 ** Foundation and appearing in the file LICENSE.GPL included in the
33 ** packaging of this file.  Please review the following information to
34 ** ensure the GNU General Public License version 3.0 requirements will be
35 ** met: http://www.gnu.org/copyleft/gpl.html.
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41
42 #include <QtCore/QString>
43 #include <QtCore/QDir>
44 #include <QtCore/QProcess>
45 #include <QStringList>
46 #include <QtGui/QImage>
47 #include <QDebug>
48 #include "imagecompare.h"
49 #include "tst_imagecompare.h"
50
51 QDir expectedDir("../images");
52 QDir actualDir("./output");
53 int diffTolerance = 0;
54
55 void tst_imagecompare::setDiffTolerance(int tolerance){
56     diffTolerance = tolerance;
57 }
58
59 void tst_imagecompare::initTestCase(){
60     QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
61     QString qtDir = env.value("QTDIR");
62     QStringList dumperpath;
63     dumperpath << "../../../tools/pngdumper/pngdumper.qml";
64
65     // Verifies that QTDIR environment variable is set
66     QCOMPARE(qtDir == "", false);
67
68     // Verifies does the expected images folder exist
69     QCOMPARE(expectedDir.exists(), true);
70
71     QProcess *myProcess = new QProcess();
72     myProcess->start(qtDir + "/bin/qmlscene", dumperpath);
73     myProcess->waitForFinished(300000);
74
75     // Verifies does the output folder exist
76     QCOMPARE(actualDir.exists(), true);
77
78     // Verifies that the output folder includes dumped png images
79     QStringList filters;
80     filters << "*.png";
81     actualDir.setNameFilters(filters);
82     QStringList list = actualDir.entryList();
83     QCOMPARE(list.size() == 0, false);
84 }
85
86 void tst_imagecompare::blend_varMode(){
87     QStringList filters;
88     filters << "Blend_mode*.png";
89     actualDir.setNameFilters(filters);
90     QStringList list = actualDir.entryList();
91
92     for (int i = 0; i < list.size(); ++i){
93         QString filename = list.at(i).toLocal8Bit().constData();
94         qDebug() << "Testing shader image " + filename;
95         QString actualFile = actualDir.absolutePath() + "/" + filename;
96         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
97
98         QImage actual(actualFile);
99         QImage expected(expectedFile);
100
101         // Verifies that pngdumper generated image is not a null size image
102         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
103
104         ImageCompare compare;
105
106         // Verifies that actual and expected images have the same size
107         QCOMPARE(compare.CompareSizes(actual, expected), true);
108
109         // Verifies that actual and expected images are pixel-wise the same
110         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
111     }
112 }
113
114 void tst_imagecompare::brightnessContrast_varBrightness(){
115     QStringList filters;
116     filters << "BrightnessContrast_brightness*.png";
117     actualDir.setNameFilters(filters);
118     QStringList list = actualDir.entryList();
119
120     for (int i = 0; i < list.size(); ++i){
121         QString filename = list.at(i).toLocal8Bit().constData();
122         qDebug() << "Testing shader image " + filename;
123         QString actualFile = actualDir.absolutePath() + "/" + filename;
124         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
125
126         QImage actual(actualFile);
127         QImage expected(expectedFile);
128
129         // Verifies that pngdumper generated image is not a null size image
130         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
131
132         ImageCompare compare;
133
134         // Verifies that actual and expected images have the same size
135         QCOMPARE(compare.CompareSizes(actual, expected), true);
136
137         // Verifies that actual and expected images are pixel-wise the same
138         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
139     }
140 }
141 void tst_imagecompare::brightnessContrast_varContrast(){
142     QStringList filters;
143     filters << "BrightnessContrast_contrast*.png";
144     actualDir.setNameFilters(filters);
145     QStringList list = actualDir.entryList();
146
147     for (int i = 0; i < list.size(); ++i){
148         QString filename = list.at(i).toLocal8Bit().constData();
149         qDebug() << "Testing shader image " + filename;
150         QString actualFile = actualDir.absolutePath() + "/" + filename;
151         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
152
153         QImage actual(actualFile);
154         QImage expected(expectedFile);
155
156         // Verifies that pngdumper generated image is not a null size image
157         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
158
159         ImageCompare compare;
160
161         // Verifies that actual and expected images have the same size
162         QCOMPARE(compare.CompareSizes(actual, expected), true);
163
164         // Verifies that actual and expected images are pixel-wise the same
165         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
166     }
167 }
168
169 void tst_imagecompare::colorize_varHue(){
170     QStringList filters;
171     filters << "Colorize_hue*.png";
172     actualDir.setNameFilters(filters);
173     QStringList list = actualDir.entryList();
174
175     for (int i = 0; i < list.size(); ++i){
176         QString filename = list.at(i).toLocal8Bit().constData();
177         qDebug() << "Testing shader image " + filename;
178         QString actualFile = actualDir.absolutePath() + "/" + filename;
179         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
180
181         QImage actual(actualFile);
182         QImage expected(expectedFile);
183
184         // Verifies that pngdumper generated image is not a null size image
185         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
186
187         ImageCompare compare;
188
189         // Verifies that actual and expected images have the same size
190         QCOMPARE(compare.CompareSizes(actual, expected), true);
191
192         // Verifies that actual and expected images are pixel-wise the same
193         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
194     }
195 }
196 void tst_imagecompare::colorize_varSaturation(){
197     QStringList filters;
198     filters << "Colorize_saturation*.png";
199     actualDir.setNameFilters(filters);
200     QStringList list = actualDir.entryList();
201
202     for (int i = 0; i < list.size(); ++i){
203         QString filename = list.at(i).toLocal8Bit().constData();
204         qDebug() << "Testing shader image " + filename;
205         QString actualFile = actualDir.absolutePath() + "/" + filename;
206         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
207
208         QImage actual(actualFile);
209         QImage expected(expectedFile);
210
211         // Verifies that pngdumper generated image is not a null size image
212         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
213
214         ImageCompare compare;
215
216         // Verifies that actual and expected images have the same size
217         QCOMPARE(compare.CompareSizes(actual, expected), true);
218
219         // Verifies that actual and expected images are pixel-wise the same
220         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
221     }
222 }
223 void tst_imagecompare::colorize_varLightness(){
224     QStringList filters;
225     filters << "Colorize_lightness*.png";
226     actualDir.setNameFilters(filters);
227     QStringList list = actualDir.entryList();
228
229     for (int i = 0; i < list.size(); ++i){
230         QString filename = list.at(i).toLocal8Bit().constData();
231         qDebug() << "Testing shader image " + filename;
232         QString actualFile = actualDir.absolutePath() + "/" + filename;
233         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
234
235         QImage actual(actualFile);
236         QImage expected(expectedFile);
237
238         // Verifies that pngdumper generated image is not a null size image
239         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
240
241         ImageCompare compare;
242
243         // Verifies that actual and expected images have the same size
244         QCOMPARE(compare.CompareSizes(actual, expected), true);
245
246         // Verifies that actual and expected images are pixel-wise the same
247         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
248     }
249 }
250
251 void tst_imagecompare::colorOverlay_varColor(){
252     QStringList filters;
253     filters << "ColorOverlay_color*.png";
254     actualDir.setNameFilters(filters);
255     QStringList list = actualDir.entryList();
256
257     for (int i = 0; i < list.size(); ++i){
258         QString filename = list.at(i).toLocal8Bit().constData();
259         qDebug() << "Testing shader image " + filename;
260         QString actualFile = actualDir.absolutePath() + "/" + filename;
261         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
262
263         QImage actual(actualFile);
264         QImage expected(expectedFile);
265
266         // Verifies that pngdumper generated image is not a null size image
267         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
268
269         ImageCompare compare;
270
271         // Verifies that actual and expected images have the same size
272         QCOMPARE(compare.CompareSizes(actual, expected), true);
273
274         // Verifies that actual and expected images are pixel-wise the same
275         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
276     }
277 }
278
279 void tst_imagecompare::conicalGradient_varAngle(){
280     QStringList filters;
281     filters << "ConicalGradient_angle*.png";
282     actualDir.setNameFilters(filters);
283     QStringList list = actualDir.entryList();
284
285     for (int i = 0; i < list.size(); ++i){
286         QString filename = list.at(i).toLocal8Bit().constData();
287         qDebug() << "Testing shader image " + filename;
288         QString actualFile = actualDir.absolutePath() + "/" + filename;
289         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
290
291         QImage actual(actualFile);
292         QImage expected(expectedFile);
293
294         // Verifies that pngdumper generated image is not a null size image
295         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
296
297         ImageCompare compare;
298
299         // Verifies that actual and expected images have the same size
300         QCOMPARE(compare.CompareSizes(actual, expected), true);
301
302         // Verifies that actual and expected images are pixel-wise the same
303         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
304     }
305 }
306 void tst_imagecompare::conicalGradient_varHorizontalOffset(){
307     QStringList filters;
308     filters << "ConicalGradient_horizontalOffset*.png";
309     actualDir.setNameFilters(filters);
310     QStringList list = actualDir.entryList();
311
312     for (int i = 0; i < list.size(); ++i){
313         QString filename = list.at(i).toLocal8Bit().constData();
314         qDebug() << "Testing shader image " + filename;
315         QString actualFile = actualDir.absolutePath() + "/" + filename;
316         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
317
318         QImage actual(actualFile);
319         QImage expected(expectedFile);
320
321         // Verifies that pngdumper generated image is not a null size image
322         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
323
324         ImageCompare compare;
325
326         // Verifies that actual and expected images have the same size
327         QCOMPARE(compare.CompareSizes(actual, expected), true);
328
329         // Verifies that actual and expected images are pixel-wise the same
330         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
331     }
332 }
333 void tst_imagecompare::conicalGradient_varVerticalOffset(){
334     QStringList filters;
335     filters << "ConicalGradient_verticalOffset*.png";
336     actualDir.setNameFilters(filters);
337     QStringList list = actualDir.entryList();
338
339     for (int i = 0; i < list.size(); ++i){
340         QString filename = list.at(i).toLocal8Bit().constData();
341         qDebug() << "Testing shader image " + filename;
342         QString actualFile = actualDir.absolutePath() + "/" + filename;
343         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
344
345         QImage actual(actualFile);
346         QImage expected(expectedFile);
347
348         // Verifies that pngdumper generated image is not a null size image
349         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
350
351         ImageCompare compare;
352
353         // Verifies that actual and expected images have the same size
354         QCOMPARE(compare.CompareSizes(actual, expected), true);
355
356         // Verifies that actual and expected images are pixel-wise the same
357         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
358     }
359 }
360 void tst_imagecompare::conicalGradient_varGradient(){
361     QStringList filters;
362     filters << "ConicalGradient_gradient*.png";
363     actualDir.setNameFilters(filters);
364     QStringList list = actualDir.entryList();
365
366     for (int i = 0; i < list.size(); ++i){
367         QString filename = list.at(i).toLocal8Bit().constData();
368         qDebug() << "Testing shader image " + filename;
369         QString actualFile = actualDir.absolutePath() + "/" + filename;
370         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
371
372         QImage actual(actualFile);
373         QImage expected(expectedFile);
374
375         // Verifies that pngdumper generated image is not a null size image
376         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
377
378         ImageCompare compare;
379
380         // Verifies that actual and expected images have the same size
381         QCOMPARE(compare.CompareSizes(actual, expected), true);
382
383         // Verifies that actual and expected images are pixel-wise the same
384         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
385     }
386 }
387 void tst_imagecompare::conicalGradient_varMaskSource(){
388     QStringList filters;
389     filters << "ConicalGradient_maskSource*.png";
390     actualDir.setNameFilters(filters);
391     QStringList list = actualDir.entryList();
392
393     for (int i = 0; i < list.size(); ++i){
394         QString filename = list.at(i).toLocal8Bit().constData();
395         qDebug() << "Testing shader image " + filename;
396         QString actualFile = actualDir.absolutePath() + "/" + filename;
397         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
398
399         QImage actual(actualFile);
400         QImage expected(expectedFile);
401
402         // Verifies that pngdumper generated image is not a null size image
403         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
404
405         ImageCompare compare;
406
407         // Verifies that actual and expected images have the same size
408         QCOMPARE(compare.CompareSizes(actual, expected), true);
409
410         // Verifies that actual and expected images are pixel-wise the same
411         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
412     }
413 }
414
415 void tst_imagecompare::desaturate_varDesaturation(){
416     QStringList filters;
417     filters << "Desaturate_desaturation*.png";
418     actualDir.setNameFilters(filters);
419     QStringList list = actualDir.entryList();
420
421     for (int i = 0; i < list.size(); ++i){
422         QString filename = list.at(i).toLocal8Bit().constData();
423         qDebug() << "Testing shader image " + filename;
424         QString actualFile = actualDir.absolutePath() + "/" + filename;
425         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
426
427         QImage actual(actualFile);
428         QImage expected(expectedFile);
429
430         // Verifies that pngdumper generated image is not a null size image
431         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
432
433         ImageCompare compare;
434
435         // Verifies that actual and expected images have the same size
436         QCOMPARE(compare.CompareSizes(actual, expected), true);
437
438         // Verifies that actual and expected images are pixel-wise the same
439         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
440     }
441 }
442
443 void tst_imagecompare::displace_varDisplacement(){
444     QStringList filters;
445     filters << "Displace_displacement*.png";
446     actualDir.setNameFilters(filters);
447     QStringList list = actualDir.entryList();
448
449     for (int i = 0; i < list.size(); ++i){
450         QString filename = list.at(i).toLocal8Bit().constData();
451         qDebug() << "Testing shader image " + filename;
452         QString actualFile = actualDir.absolutePath() + "/" + filename;
453         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
454
455         QImage actual(actualFile);
456         QImage expected(expectedFile);
457
458         // Verifies that pngdumper generated image is not a null size image
459         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
460
461         ImageCompare compare;
462
463         // Verifies that actual and expected images have the same size
464         QCOMPARE(compare.CompareSizes(actual, expected), true);
465
466         // Verifies that actual and expected images are pixel-wise the same
467         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
468     }
469 }
470
471 void tst_imagecompare::dropShadow_varRadius(){
472     QStringList filters;
473     filters << "DropShadow_radius*.png";
474     actualDir.setNameFilters(filters);
475     QStringList list = actualDir.entryList();
476
477     for (int i = 0; i < list.size(); ++i){
478         QString filename = list.at(i).toLocal8Bit().constData();
479         qDebug() << "Testing shader image " + filename;
480         QString actualFile = actualDir.absolutePath() + "/" + filename;
481         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
482
483         QImage actual(actualFile);
484         QImage expected(expectedFile);
485
486         // Verifies that pngdumper generated image is not a null size image
487         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
488
489         ImageCompare compare;
490
491         // Verifies that actual and expected images have the same size
492         QCOMPARE(compare.CompareSizes(actual, expected), true);
493
494         // Verifies that actual and expected images are pixel-wise the same
495         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
496     }
497 }
498 void tst_imagecompare::dropShadow_varColor(){
499     QStringList filters;
500     filters << "DropShadow_color*.png";
501     actualDir.setNameFilters(filters);
502     QStringList list = actualDir.entryList();
503
504     for (int i = 0; i < list.size(); ++i){
505         QString filename = list.at(i).toLocal8Bit().constData();
506         qDebug() << "Testing shader image " + filename;
507         QString actualFile = actualDir.absolutePath() + "/" + filename;
508         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
509
510         QImage actual(actualFile);
511         QImage expected(expectedFile);
512
513         // Verifies that pngdumper generated image is not a null size image
514         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
515
516         ImageCompare compare;
517
518         // Verifies that actual and expected images have the same size
519         QCOMPARE(compare.CompareSizes(actual, expected), true);
520
521         // Verifies that actual and expected images are pixel-wise the same
522         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
523     }
524 }
525 void tst_imagecompare::dropShadow_varHorizontalOffset(){
526     QStringList filters;
527     filters << "DropShadow_horizontalOffset*.png";
528     actualDir.setNameFilters(filters);
529     QStringList list = actualDir.entryList();
530
531     for (int i = 0; i < list.size(); ++i){
532         QString filename = list.at(i).toLocal8Bit().constData();
533         qDebug() << "Testing shader image " + filename;
534         QString actualFile = actualDir.absolutePath() + "/" + filename;
535         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
536
537         QImage actual(actualFile);
538         QImage expected(expectedFile);
539
540         // Verifies that pngdumper generated image is not a null size image
541         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
542
543         ImageCompare compare;
544
545         // Verifies that actual and expected images have the same size
546         QCOMPARE(compare.CompareSizes(actual, expected), true);
547
548         // Verifies that actual and expected images are pixel-wise the same
549         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
550     }
551 }
552 void tst_imagecompare::dropShadow_varVerticalOffset(){
553     QStringList filters;
554     filters << "DropShadow_verticalOffset*.png";
555     actualDir.setNameFilters(filters);
556     QStringList list = actualDir.entryList();
557
558     for (int i = 0; i < list.size(); ++i){
559         QString filename = list.at(i).toLocal8Bit().constData();
560         qDebug() << "Testing shader image " + filename;
561         QString actualFile = actualDir.absolutePath() + "/" + filename;
562         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
563
564         QImage actual(actualFile);
565         QImage expected(expectedFile);
566
567         // Verifies that pngdumper generated image is not a null size image
568         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
569
570         ImageCompare compare;
571
572         // Verifies that actual and expected images have the same size
573         QCOMPARE(compare.CompareSizes(actual, expected), true);
574
575         // Verifies that actual and expected images are pixel-wise the same
576         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
577     }
578 }
579 void tst_imagecompare::dropShadow_varSpread(){
580     QStringList filters;
581     filters << "DropShadow_spread*.png";
582     actualDir.setNameFilters(filters);
583     QStringList list = actualDir.entryList();
584
585     for (int i = 0; i < list.size(); ++i){
586         QString filename = list.at(i).toLocal8Bit().constData();
587         qDebug() << "Testing shader image " + filename;
588         QString actualFile = actualDir.absolutePath() + "/" + filename;
589         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
590
591         QImage actual(actualFile);
592         QImage expected(expectedFile);
593
594         // Verifies that pngdumper generated image is not a null size image
595         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
596
597         ImageCompare compare;
598
599         // Verifies that actual and expected images have the same size
600         QCOMPARE(compare.CompareSizes(actual, expected), true);
601
602         // Verifies that actual and expected images are pixel-wise the same
603         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
604     }
605 }
606 void tst_imagecompare::dropShadow_varFast(){
607     QStringList filters;
608     filters << "DropShadow_fast*.png";
609     actualDir.setNameFilters(filters);
610     QStringList list = actualDir.entryList();
611
612     for (int i = 0; i < list.size(); ++i){
613         QString filename = list.at(i).toLocal8Bit().constData();
614         qDebug() << "Testing shader image " + filename;
615         QString actualFile = actualDir.absolutePath() + "/" + filename;
616         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
617
618         QImage actual(actualFile);
619         QImage expected(expectedFile);
620
621         // Verifies that pngdumper generated image is not a null size image
622         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
623
624         ImageCompare compare;
625
626         // Verifies that actual and expected images have the same size
627         QCOMPARE(compare.CompareSizes(actual, expected), true);
628
629         // Verifies that actual and expected images are pixel-wise the same
630         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
631     }
632 }
633
634 void tst_imagecompare::glow_varRadius(){
635     QStringList filters;
636     filters << "Glow_radius*.png";
637     actualDir.setNameFilters(filters);
638     QStringList list = actualDir.entryList();
639
640     for (int i = 0; i < list.size(); ++i){
641         QString filename = list.at(i).toLocal8Bit().constData();
642         qDebug() << "Testing shader image " + filename;
643         QString actualFile = actualDir.absolutePath() + "/" + filename;
644         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
645
646         QImage actual(actualFile);
647         QImage expected(expectedFile);
648
649         // Verifies that pngdumper generated image is not a null size image
650         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
651
652         ImageCompare compare;
653
654         // Verifies that actual and expected images have the same size
655         QCOMPARE(compare.CompareSizes(actual, expected), true);
656
657         // Verifies that actual and expected images are pixel-wise the same
658         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
659     }
660 }
661 void tst_imagecompare::glow_varColor(){
662     QStringList filters;
663     filters << "Glow_color*.png";
664     actualDir.setNameFilters(filters);
665     QStringList list = actualDir.entryList();
666
667     for (int i = 0; i < list.size(); ++i){
668         QString filename = list.at(i).toLocal8Bit().constData();
669         qDebug() << "Testing shader image " + filename;
670         QString actualFile = actualDir.absolutePath() + "/" + filename;
671         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
672
673         QImage actual(actualFile);
674         QImage expected(expectedFile);
675
676         // Verifies that pngdumper generated image is not a null size image
677         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
678
679         ImageCompare compare;
680
681         // Verifies that actual and expected images have the same size
682         QCOMPARE(compare.CompareSizes(actual, expected), true);
683
684         // Verifies that actual and expected images are pixel-wise the same
685         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
686     }
687 }
688 void tst_imagecompare::glow_varSpread(){
689     QStringList filters;
690     filters << "Glow_spread*.png";
691     actualDir.setNameFilters(filters);
692     QStringList list = actualDir.entryList();
693
694     for (int i = 0; i < list.size(); ++i){
695         QString filename = list.at(i).toLocal8Bit().constData();
696         qDebug() << "Testing shader image " + filename;
697         QString actualFile = actualDir.absolutePath() + "/" + filename;
698         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
699
700         QImage actual(actualFile);
701         QImage expected(expectedFile);
702
703         // Verifies that pngdumper generated image is not a null size image
704         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
705
706         ImageCompare compare;
707
708         // Verifies that actual and expected images have the same size
709         QCOMPARE(compare.CompareSizes(actual, expected), true);
710
711         // Verifies that actual and expected images are pixel-wise the same
712         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
713     }
714 }
715 void tst_imagecompare::glow_varFast(){
716     QStringList filters;
717     filters << "Glow_fast*.png";
718     actualDir.setNameFilters(filters);
719     QStringList list = actualDir.entryList();
720
721     for (int i = 0; i < list.size(); ++i){
722         QString filename = list.at(i).toLocal8Bit().constData();
723         qDebug() << "Testing shader image " + filename;
724         QString actualFile = actualDir.absolutePath() + "/" + filename;
725         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
726
727         QImage actual(actualFile);
728         QImage expected(expectedFile);
729
730         // Verifies that pngdumper generated image is not a null size image
731         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
732
733         ImageCompare compare;
734
735         // Verifies that actual and expected images have the same size
736         QCOMPARE(compare.CompareSizes(actual, expected), true);
737
738         // Verifies that actual and expected images are pixel-wise the same
739         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
740     }
741 }
742
743 void tst_imagecompare::fastBlur_varBlur(){
744     QStringList filters;
745     filters << "FastBlur_blur*.png";
746     actualDir.setNameFilters(filters);
747     QStringList list = actualDir.entryList();
748
749     for (int i = 0; i < list.size(); ++i){
750         QString filename = list.at(i).toLocal8Bit().constData();
751         qDebug() << "Testing shader image " + filename;
752         QString actualFile = actualDir.absolutePath() + "/" + filename;
753         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
754
755         QImage actual(actualFile);
756         QImage expected(expectedFile);
757
758         // Verifies that pngdumper generated image is not a null size image
759         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
760
761         ImageCompare compare;
762
763         // Verifies that actual and expected images have the same size
764         QCOMPARE(compare.CompareSizes(actual, expected), true);
765
766         // Verifies that actual and expected images are pixel-wise the same
767         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
768     }
769 }
770 void tst_imagecompare::fastBlur_varTransparentBorder(){
771     QStringList filters;
772     filters << "FastBlur_transparentBorder*.png";
773     actualDir.setNameFilters(filters);
774     QStringList list = actualDir.entryList();
775
776     for (int i = 0; i < list.size(); ++i){
777         QString filename = list.at(i).toLocal8Bit().constData();
778         qDebug() << "Testing shader image " + filename;
779         QString actualFile = actualDir.absolutePath() + "/" + filename;
780         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
781
782         QImage actual(actualFile);
783         QImage expected(expectedFile);
784
785         // Verifies that pngdumper generated image is not a null size image
786         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
787
788         ImageCompare compare;
789
790         // Verifies that actual and expected images have the same size
791         QCOMPARE(compare.CompareSizes(actual, expected), true);
792
793         // Verifies that actual and expected images are pixel-wise the same
794         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
795     }
796 }
797
798 void tst_imagecompare::gammaAdjust_varGamma(){
799     QStringList filters;
800     filters << "GammaAdjust_gamma*.png";
801     actualDir.setNameFilters(filters);
802     QStringList list = actualDir.entryList();
803
804     for (int i = 0; i < list.size(); ++i){
805         QString filename = list.at(i).toLocal8Bit().constData();
806         qDebug() << "Testing shader image " + filename;
807         QString actualFile = actualDir.absolutePath() + "/" + filename;
808         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
809
810         QImage actual(actualFile);
811         QImage expected(expectedFile);
812
813         // Verifies that pngdumper generated image is not a null size image
814         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
815
816         ImageCompare compare;
817
818         // Verifies that actual and expected images have the same size
819         QCOMPARE(compare.CompareSizes(actual, expected), true);
820
821         // Verifies that actual and expected images are pixel-wise the same
822         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
823     }
824 }
825
826 void tst_imagecompare::gaussianBlur_varRadius(){
827     QStringList filters;
828     filters << "GaussianBlur_radius*.png";
829     actualDir.setNameFilters(filters);
830     QStringList list = actualDir.entryList();
831
832     for (int i = 0; i < list.size(); ++i){
833         QString filename = list.at(i).toLocal8Bit().constData();
834         qDebug() << "Testing shader image " + filename;
835         QString actualFile = actualDir.absolutePath() + "/" + filename;
836         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
837
838         QImage actual(actualFile);
839         QImage expected(expectedFile);
840
841         // Verifies that pngdumper generated image is not a null size image
842         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
843
844         ImageCompare compare;
845
846         // Verifies that actual and expected images have the same size
847         QCOMPARE(compare.CompareSizes(actual, expected), true);
848
849         // Verifies that actual and expected images are pixel-wise the same
850         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
851     }
852 }
853 void tst_imagecompare::gaussianBlur_varDeviation(){
854     QStringList filters;
855     filters << "GaussianBlur_deviation*.png";
856     actualDir.setNameFilters(filters);
857     QStringList list = actualDir.entryList();
858
859     for (int i = 0; i < list.size(); ++i){
860         QString filename = list.at(i).toLocal8Bit().constData();
861         qDebug() << "Testing shader image " + filename;
862         QString actualFile = actualDir.absolutePath() + "/" + filename;
863         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
864
865         QImage actual(actualFile);
866         QImage expected(expectedFile);
867
868         // Verifies that pngdumper generated image is not a null size image
869         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
870
871         ImageCompare compare;
872
873         // Verifies that actual and expected images have the same size
874         QCOMPARE(compare.CompareSizes(actual, expected), true);
875
876         // Verifies that actual and expected images are pixel-wise the same
877         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
878     }
879 }
880 void tst_imagecompare::gaussianBlur_varTransparentBorder(){
881     QStringList filters;
882     filters << "GaussianBlur_transparentBorder*.png";
883     actualDir.setNameFilters(filters);
884     QStringList list = actualDir.entryList();
885
886     for (int i = 0; i < list.size(); ++i){
887         QString filename = list.at(i).toLocal8Bit().constData();
888         qDebug() << "Testing shader image " + filename;
889         QString actualFile = actualDir.absolutePath() + "/" + filename;
890         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
891
892         QImage actual(actualFile);
893         QImage expected(expectedFile);
894
895         // Verifies that pngdumper generated image is not a null size image
896         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
897
898         ImageCompare compare;
899
900         // Verifies that actual and expected images have the same size
901         QCOMPARE(compare.CompareSizes(actual, expected), true);
902
903         // Verifies that actual and expected images are pixel-wise the same
904         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
905     }
906 }
907
908 void tst_imagecompare::hueSaturation_varHue(){
909     QStringList filters;
910     filters << "HueSaturation_hue*.png";
911     actualDir.setNameFilters(filters);
912     QStringList list = actualDir.entryList();
913
914     for (int i = 0; i < list.size(); ++i){
915         QString filename = list.at(i).toLocal8Bit().constData();
916         qDebug() << "Testing shader image " + filename;
917         QString actualFile = actualDir.absolutePath() + "/" + filename;
918         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
919
920         QImage actual(actualFile);
921         QImage expected(expectedFile);
922
923         // Verifies that pngdumper generated image is not a null size image
924         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
925
926         ImageCompare compare;
927
928         // Verifies that actual and expected images have the same size
929         QCOMPARE(compare.CompareSizes(actual, expected), true);
930
931         // Verifies that actual and expected images are pixel-wise the same
932         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
933     }
934 }
935 void tst_imagecompare::hueSaturation_varSaturation(){
936     QStringList filters;
937     filters << "HueSaturation_saturation*.png";
938     actualDir.setNameFilters(filters);
939     QStringList list = actualDir.entryList();
940
941     for (int i = 0; i < list.size(); ++i){
942         QString filename = list.at(i).toLocal8Bit().constData();
943         qDebug() << "Testing shader image " + filename;
944         QString actualFile = actualDir.absolutePath() + "/" + filename;
945         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
946
947         QImage actual(actualFile);
948         QImage expected(expectedFile);
949
950         // Verifies that pngdumper generated image is not a null size image
951         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
952
953         ImageCompare compare;
954
955         // Verifies that actual and expected images have the same size
956         QCOMPARE(compare.CompareSizes(actual, expected), true);
957
958         // Verifies that actual and expected images are pixel-wise the same
959         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
960     }
961 }
962 void tst_imagecompare::hueSaturation_varLightness(){
963     QStringList filters;
964     filters << "HueSaturation_lightness*.png";
965     actualDir.setNameFilters(filters);
966     QStringList list = actualDir.entryList();
967
968     for (int i = 0; i < list.size(); ++i){
969         QString filename = list.at(i).toLocal8Bit().constData();
970         qDebug() << "Testing shader image " + filename;
971         QString actualFile = actualDir.absolutePath() + "/" + filename;
972         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
973
974         QImage actual(actualFile);
975         QImage expected(expectedFile);
976
977         // Verifies that pngdumper generated image is not a null size image
978         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
979
980         ImageCompare compare;
981
982         // Verifies that actual and expected images have the same size
983         QCOMPARE(compare.CompareSizes(actual, expected), true);
984
985         // Verifies that actual and expected images are pixel-wise the same
986         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
987     }
988 }
989
990 void tst_imagecompare::innerShadow_varRadius(){
991     QStringList filters;
992     filters << "InnerShadow_radius*.png";
993     actualDir.setNameFilters(filters);
994     QStringList list = actualDir.entryList();
995
996     for (int i = 0; i < list.size(); ++i){
997         QString filename = list.at(i).toLocal8Bit().constData();
998         qDebug() << "Testing shader image " + filename;
999         QString actualFile = actualDir.absolutePath() + "/" + filename;
1000         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1001
1002         QImage actual(actualFile);
1003         QImage expected(expectedFile);
1004
1005         // Verifies that pngdumper generated image is not a null size image
1006         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1007
1008         ImageCompare compare;
1009
1010         // Verifies that actual and expected images have the same size
1011         QCOMPARE(compare.CompareSizes(actual, expected), true);
1012
1013         // Verifies that actual and expected images are pixel-wise the same
1014         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1015     }
1016 }
1017 void tst_imagecompare::innerShadow_varHorizontalOffset(){
1018     QStringList filters;
1019     filters << "InnerShadow_horizontalOffset*.png";
1020     actualDir.setNameFilters(filters);
1021     QStringList list = actualDir.entryList();
1022
1023     for (int i = 0; i < list.size(); ++i){
1024         QString filename = list.at(i).toLocal8Bit().constData();
1025         qDebug() << "Testing shader image " + filename;
1026         QString actualFile = actualDir.absolutePath() + "/" + filename;
1027         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1028
1029         QImage actual(actualFile);
1030         QImage expected(expectedFile);
1031
1032         // Verifies that pngdumper generated image is not a null size image
1033         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1034
1035         ImageCompare compare;
1036
1037         // Verifies that actual and expected images have the same size
1038         QCOMPARE(compare.CompareSizes(actual, expected), true);
1039
1040         // Verifies that actual and expected images are pixel-wise the same
1041         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1042     }
1043 }
1044 void tst_imagecompare::innerShadow_varVerticalOffset(){
1045     QStringList filters;
1046     filters << "InnerShadow_verticalOffset*.png";
1047     actualDir.setNameFilters(filters);
1048     QStringList list = actualDir.entryList();
1049
1050     for (int i = 0; i < list.size(); ++i){
1051         QString filename = list.at(i).toLocal8Bit().constData();
1052         qDebug() << "Testing shader image " + filename;
1053         QString actualFile = actualDir.absolutePath() + "/" + filename;
1054         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1055
1056         QImage actual(actualFile);
1057         QImage expected(expectedFile);
1058
1059         // Verifies that pngdumper generated image is not a null size image
1060         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1061
1062         ImageCompare compare;
1063
1064         // Verifies that actual and expected images have the same size
1065         QCOMPARE(compare.CompareSizes(actual, expected), true);
1066
1067         // Verifies that actual and expected images are pixel-wise the same
1068         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1069     }
1070 }
1071 void tst_imagecompare::innerShadow_varSpread(){
1072     QStringList filters;
1073     filters << "InnerShadow_spread*.png";
1074     actualDir.setNameFilters(filters);
1075     QStringList list = actualDir.entryList();
1076
1077     for (int i = 0; i < list.size(); ++i){
1078         QString filename = list.at(i).toLocal8Bit().constData();
1079         qDebug() << "Testing shader image " + filename;
1080         QString actualFile = actualDir.absolutePath() + "/" + filename;
1081         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1082
1083         QImage actual(actualFile);
1084         QImage expected(expectedFile);
1085
1086         // Verifies that pngdumper generated image is not a null size image
1087         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1088
1089         ImageCompare compare;
1090
1091         // Verifies that actual and expected images have the same size
1092         QCOMPARE(compare.CompareSizes(actual, expected), true);
1093
1094         // Verifies that actual and expected images are pixel-wise the same
1095         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1096     }
1097 }
1098 void tst_imagecompare::innerShadow_varFast(){
1099     QStringList filters;
1100     filters << "InnerShadow_fast*.png";
1101     actualDir.setNameFilters(filters);
1102     QStringList list = actualDir.entryList();
1103
1104     for (int i = 0; i < list.size(); ++i){
1105         QString filename = list.at(i).toLocal8Bit().constData();
1106         qDebug() << "Testing shader image " + filename;
1107         QString actualFile = actualDir.absolutePath() + "/" + filename;
1108         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1109
1110         QImage actual(actualFile);
1111         QImage expected(expectedFile);
1112
1113         // Verifies that pngdumper generated image is not a null size image
1114         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1115
1116         ImageCompare compare;
1117
1118         // Verifies that actual and expected images have the same size
1119         QCOMPARE(compare.CompareSizes(actual, expected), true);
1120
1121         // Verifies that actual and expected images are pixel-wise the same
1122         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1123     }
1124 }
1125 void tst_imagecompare::innerShadow_varColor(){
1126     QStringList filters;
1127     filters << "InnerShadow_color*.png";
1128     actualDir.setNameFilters(filters);
1129     QStringList list = actualDir.entryList();
1130
1131     for (int i = 0; i < list.size(); ++i){
1132         QString filename = list.at(i).toLocal8Bit().constData();
1133         qDebug() << "Testing shader image " + filename;
1134         QString actualFile = actualDir.absolutePath() + "/" + filename;
1135         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1136
1137         QImage actual(actualFile);
1138         QImage expected(expectedFile);
1139
1140         // Verifies that pngdumper generated image is not a null size image
1141         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1142
1143         ImageCompare compare;
1144
1145         // Verifies that actual and expected images have the same size
1146         QCOMPARE(compare.CompareSizes(actual, expected), true);
1147
1148         // Verifies that actual and expected images are pixel-wise the same
1149         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1150     }
1151 }
1152
1153 void tst_imagecompare::linearGradient_varGradient(){
1154     QStringList filters;
1155     filters << "LinearGradient_gradient*.png";
1156     actualDir.setNameFilters(filters);
1157     QStringList list = actualDir.entryList();
1158
1159     for (int i = 0; i < list.size(); ++i){
1160         QString filename = list.at(i).toLocal8Bit().constData();
1161         qDebug() << "Testing shader image " + filename;
1162         QString actualFile = actualDir.absolutePath() + "/" + filename;
1163         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1164
1165         QImage actual(actualFile);
1166         QImage expected(expectedFile);
1167
1168         // Verifies that pngdumper generated image is not a null size image
1169         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1170
1171         ImageCompare compare;
1172
1173         // Verifies that actual and expected images have the same size
1174         QCOMPARE(compare.CompareSizes(actual, expected), true);
1175
1176         // Verifies that actual and expected images are pixel-wise the same
1177         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1178     }
1179 }
1180 void tst_imagecompare::linearGradient_varStart(){
1181     QStringList filters;
1182     filters << "LinearGradient_start*.png";
1183     actualDir.setNameFilters(filters);
1184     QStringList list = actualDir.entryList();
1185
1186     for (int i = 0; i < list.size(); ++i){
1187         QString filename = list.at(i).toLocal8Bit().constData();
1188         qDebug() << "Testing shader image " + filename;
1189         QString actualFile = actualDir.absolutePath() + "/" + filename;
1190         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1191
1192         QImage actual(actualFile);
1193         QImage expected(expectedFile);
1194
1195         // Verifies that pngdumper generated image is not a null size image
1196         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1197
1198         ImageCompare compare;
1199
1200         // Verifies that actual and expected images have the same size
1201         QCOMPARE(compare.CompareSizes(actual, expected), true);
1202
1203         // Verifies that actual and expected images are pixel-wise the same
1204         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1205     }
1206 }
1207 void tst_imagecompare::linearGradient_varEnd(){
1208     QStringList filters;
1209     filters << "LinearGradient_end*.png";
1210     actualDir.setNameFilters(filters);
1211     QStringList list = actualDir.entryList();
1212
1213     for (int i = 0; i < list.size(); ++i){
1214         QString filename = list.at(i).toLocal8Bit().constData();
1215         qDebug() << "Testing shader image " + filename;
1216         QString actualFile = actualDir.absolutePath() + "/" + filename;
1217         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1218
1219         QImage actual(actualFile);
1220         QImage expected(expectedFile);
1221
1222         // Verifies that pngdumper generated image is not a null size image
1223         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1224
1225         ImageCompare compare;
1226
1227         // Verifies that actual and expected images have the same size
1228         QCOMPARE(compare.CompareSizes(actual, expected), true);
1229
1230         // Verifies that actual and expected images are pixel-wise the same
1231         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1232     }
1233 }
1234 void tst_imagecompare::linearGradient_varMaskSource(){
1235     QStringList filters;
1236     filters << "LinearGradient_maskSource*.png";
1237     actualDir.setNameFilters(filters);
1238     QStringList list = actualDir.entryList();
1239
1240     for (int i = 0; i < list.size(); ++i){
1241         QString filename = list.at(i).toLocal8Bit().constData();
1242         qDebug() << "Testing shader image " + filename;
1243         QString actualFile = actualDir.absolutePath() + "/" + filename;
1244         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1245
1246         QImage actual(actualFile);
1247         QImage expected(expectedFile);
1248
1249         // Verifies that pngdumper generated image is not a null size image
1250         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1251
1252         ImageCompare compare;
1253
1254         // Verifies that actual and expected images have the same size
1255         QCOMPARE(compare.CompareSizes(actual, expected), true);
1256
1257         // Verifies that actual and expected images are pixel-wise the same
1258         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1259     }
1260 }
1261
1262 void tst_imagecompare::opacityMask_varMaskSource(){
1263     QStringList filters;
1264     filters << "OpacityMask_maskSource*.png";
1265     actualDir.setNameFilters(filters);
1266     QStringList list = actualDir.entryList();
1267
1268     for (int i = 0; i < list.size(); ++i){
1269         QString filename = list.at(i).toLocal8Bit().constData();
1270         qDebug() << "Testing shader image " + filename;
1271         QString actualFile = actualDir.absolutePath() + "/" + filename;
1272         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1273
1274         QImage actual(actualFile);
1275         QImage expected(expectedFile);
1276
1277         // Verifies that pngdumper generated image is not a null size image
1278         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1279
1280         ImageCompare compare;
1281
1282         // Verifies that actual and expected images have the same size
1283         QCOMPARE(compare.CompareSizes(actual, expected), true);
1284
1285         // Verifies that actual and expected images are pixel-wise the same
1286         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1287     }
1288 }
1289
1290 void tst_imagecompare::radialGradient_varHorizontalOffset(){
1291     QStringList filters;
1292     filters << "RadialGradient_horizontalOffset*.png";
1293     actualDir.setNameFilters(filters);
1294     QStringList list = actualDir.entryList();
1295
1296     for (int i = 0; i < list.size(); ++i){
1297         QString filename = list.at(i).toLocal8Bit().constData();
1298         qDebug() << "Testing shader image " + filename;
1299         QString actualFile = actualDir.absolutePath() + "/" + filename;
1300         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1301
1302         QImage actual(actualFile);
1303         QImage expected(expectedFile);
1304
1305         // Verifies that pngdumper generated image is not a null size image
1306         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1307
1308         ImageCompare compare;
1309
1310         // Verifies that actual and expected images have the same size
1311         QCOMPARE(compare.CompareSizes(actual, expected), true);
1312
1313         // Verifies that actual and expected images are pixel-wise the same
1314         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1315     }
1316 }
1317 void tst_imagecompare::radialGradient_varVerticalOffset(){
1318     QStringList filters;
1319     filters << "RadialGradient_verticalOffset*.png";
1320     actualDir.setNameFilters(filters);
1321     QStringList list = actualDir.entryList();
1322
1323     for (int i = 0; i < list.size(); ++i){
1324         QString filename = list.at(i).toLocal8Bit().constData();
1325         qDebug() << "Testing shader image " + filename;
1326         QString actualFile = actualDir.absolutePath() + "/" + filename;
1327         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1328
1329         QImage actual(actualFile);
1330         QImage expected(expectedFile);
1331
1332         // Verifies that pngdumper generated image is not a null size image
1333         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1334
1335         ImageCompare compare;
1336
1337         // Verifies that actual and expected images have the same size
1338         QCOMPARE(compare.CompareSizes(actual, expected), true);
1339
1340         // Verifies that actual and expected images are pixel-wise the same
1341         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1342     }
1343 }
1344 void tst_imagecompare::radialGradient_varHorizontalRadius(){
1345     QStringList filters;
1346     filters << "RadialGradient_horizontalRadius*.png";
1347     actualDir.setNameFilters(filters);
1348     QStringList list = actualDir.entryList();
1349
1350     for (int i = 0; i < list.size(); ++i){
1351         QString filename = list.at(i).toLocal8Bit().constData();
1352         qDebug() << "Testing shader image " + filename;
1353         QString actualFile = actualDir.absolutePath() + "/" + filename;
1354         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1355
1356         QImage actual(actualFile);
1357         QImage expected(expectedFile);
1358
1359         // Verifies that pngdumper generated image is not a null size image
1360         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1361
1362         ImageCompare compare;
1363
1364         // Verifies that actual and expected images have the same size
1365         QCOMPARE(compare.CompareSizes(actual, expected), true);
1366
1367         // Verifies that actual and expected images are pixel-wise the same
1368         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1369     }
1370 }
1371 void tst_imagecompare::radialGradient_varVerticalRadius(){
1372     QStringList filters;
1373     filters << "RadialGradient_verticalRadius*.png";
1374     actualDir.setNameFilters(filters);
1375     QStringList list = actualDir.entryList();
1376
1377     for (int i = 0; i < list.size(); ++i){
1378         QString filename = list.at(i).toLocal8Bit().constData();
1379         qDebug() << "Testing shader image " + filename;
1380         QString actualFile = actualDir.absolutePath() + "/" + filename;
1381         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1382
1383         QImage actual(actualFile);
1384         QImage expected(expectedFile);
1385
1386         // Verifies that pngdumper generated image is not a null size image
1387         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1388
1389         ImageCompare compare;
1390
1391         // Verifies that actual and expected images have the same size
1392         QCOMPARE(compare.CompareSizes(actual, expected), true);
1393
1394         // Verifies that actual and expected images are pixel-wise the same
1395         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1396     }
1397 }
1398 void tst_imagecompare::radialGradient_varGradient(){
1399     QStringList filters;
1400     filters << "RadialGradient_gradient*.png";
1401     actualDir.setNameFilters(filters);
1402     QStringList list = actualDir.entryList();
1403
1404     for (int i = 0; i < list.size(); ++i){
1405         QString filename = list.at(i).toLocal8Bit().constData();
1406         qDebug() << "Testing shader image " + filename;
1407         QString actualFile = actualDir.absolutePath() + "/" + filename;
1408         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1409
1410         QImage actual(actualFile);
1411         QImage expected(expectedFile);
1412
1413         // Verifies that pngdumper generated image is not a null size image
1414         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1415
1416         ImageCompare compare;
1417
1418         // Verifies that actual and expected images have the same size
1419         QCOMPARE(compare.CompareSizes(actual, expected), true);
1420
1421         // Verifies that actual and expected images are pixel-wise the same
1422         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1423     }
1424 }
1425 void tst_imagecompare::radialGradient_varAngle(){
1426     QStringList filters;
1427     filters << "RadialGradient_angle*.png";
1428     actualDir.setNameFilters(filters);
1429     QStringList list = actualDir.entryList();
1430
1431     for (int i = 0; i < list.size(); ++i){
1432         QString filename = list.at(i).toLocal8Bit().constData();
1433         qDebug() << "Testing shader image " + filename;
1434         QString actualFile = actualDir.absolutePath() + "/" + filename;
1435         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1436
1437         QImage actual(actualFile);
1438         QImage expected(expectedFile);
1439
1440         // Verifies that pngdumper generated image is not a null size image
1441         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1442
1443         ImageCompare compare;
1444
1445         // Verifies that actual and expected images have the same size
1446         QCOMPARE(compare.CompareSizes(actual, expected), true);
1447
1448         // Verifies that actual and expected images are pixel-wise the same
1449         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1450     }
1451 }
1452 void tst_imagecompare::radialGradient_varMaskSource(){
1453     QStringList filters;
1454     filters << "RadialGradient_maskSource*.png";
1455     actualDir.setNameFilters(filters);
1456     QStringList list = actualDir.entryList();
1457
1458     for (int i = 0; i < list.size(); ++i){
1459         QString filename = list.at(i).toLocal8Bit().constData();
1460         qDebug() << "Testing shader image " + filename;
1461         QString actualFile = actualDir.absolutePath() + "/" + filename;
1462         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1463
1464         QImage actual(actualFile);
1465         QImage expected(expectedFile);
1466
1467         // Verifies that pngdumper generated image is not a null size image
1468         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1469
1470         ImageCompare compare;
1471
1472         // Verifies that actual and expected images have the same size
1473         QCOMPARE(compare.CompareSizes(actual, expected), true);
1474
1475         // Verifies that actual and expected images are pixel-wise the same
1476         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1477     }
1478 }
1479
1480 void tst_imagecompare::rectangularGlow_varGlowRadius(){
1481     QStringList filters;
1482     filters << "RectangularGlow_glowRadius*.png";
1483     actualDir.setNameFilters(filters);
1484     QStringList list = actualDir.entryList();
1485
1486     for (int i = 0; i < list.size(); ++i){
1487         QString filename = list.at(i).toLocal8Bit().constData();
1488         qDebug() << "Testing shader image " + filename;
1489         QString actualFile = actualDir.absolutePath() + "/" + filename;
1490         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1491
1492         QImage actual(actualFile);
1493         QImage expected(expectedFile);
1494
1495         // Verifies that pngdumper generated image is not a null size image
1496         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1497
1498         ImageCompare compare;
1499
1500         // Verifies that actual and expected images have the same size
1501         QCOMPARE(compare.CompareSizes(actual, expected), true);
1502
1503         // Verifies that actual and expected images are pixel-wise the same
1504         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1505     }
1506 }
1507 void tst_imagecompare::rectangularGlow_varSpread(){
1508     QStringList filters;
1509     filters << "RectangularGlow_spread*.png";
1510     actualDir.setNameFilters(filters);
1511     QStringList list = actualDir.entryList();
1512
1513     for (int i = 0; i < list.size(); ++i){
1514         QString filename = list.at(i).toLocal8Bit().constData();
1515         qDebug() << "Testing shader image " + filename;
1516         QString actualFile = actualDir.absolutePath() + "/" + filename;
1517         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1518
1519         QImage actual(actualFile);
1520         QImage expected(expectedFile);
1521
1522         // Verifies that pngdumper generated image is not a null size image
1523         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1524
1525         ImageCompare compare;
1526
1527         // Verifies that actual and expected images have the same size
1528         QCOMPARE(compare.CompareSizes(actual, expected), true);
1529
1530         // Verifies that actual and expected images are pixel-wise the same
1531         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1532     }
1533 }
1534 void tst_imagecompare::rectangularGlow_varColor(){
1535     QStringList filters;
1536     filters << "RectangularGlow_color*.png";
1537     actualDir.setNameFilters(filters);
1538     QStringList list = actualDir.entryList();
1539
1540     for (int i = 0; i < list.size(); ++i){
1541         QString filename = list.at(i).toLocal8Bit().constData();
1542         qDebug() << "Testing shader image " + filename;
1543         QString actualFile = actualDir.absolutePath() + "/" + filename;
1544         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1545
1546         QImage actual(actualFile);
1547         QImage expected(expectedFile);
1548
1549         // Verifies that pngdumper generated image is not a null size image
1550         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1551
1552         ImageCompare compare;
1553
1554         // Verifies that actual and expected images have the same size
1555         QCOMPARE(compare.CompareSizes(actual, expected), true);
1556
1557         // Verifies that actual and expected images are pixel-wise the same
1558         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1559     }
1560 }
1561 void tst_imagecompare::rectangularGlow_varCornerRadius(){
1562     QStringList filters;
1563     filters << "RectangularGlow_cornerRadius*.png";
1564     actualDir.setNameFilters(filters);
1565     QStringList list = actualDir.entryList();
1566
1567     for (int i = 0; i < list.size(); ++i){
1568         QString filename = list.at(i).toLocal8Bit().constData();
1569         qDebug() << "Testing shader image " + filename;
1570         QString actualFile = actualDir.absolutePath() + "/" + filename;
1571         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1572
1573         QImage actual(actualFile);
1574         QImage expected(expectedFile);
1575
1576         // Verifies that pngdumper generated image is not a null size image
1577         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1578
1579         ImageCompare compare;
1580
1581         // Verifies that actual and expected images have the same size
1582         QCOMPARE(compare.CompareSizes(actual, expected), true);
1583
1584         // Verifies that actual and expected images are pixel-wise the same
1585         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1586     }
1587 }
1588
1589 void tst_imagecompare::recursiveBlur_varLoops(){
1590     QStringList filters;
1591     filters << "RecursiveBlur_loops*.png";
1592     actualDir.setNameFilters(filters);
1593     QStringList list = actualDir.entryList();
1594
1595     for (int i = 0; i < list.size(); ++i){
1596         QString filename = list.at(i).toLocal8Bit().constData();
1597         qDebug() << "Testing shader image " + filename;
1598         QString actualFile = actualDir.absolutePath() + "/" + filename;
1599         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1600
1601         QImage actual(actualFile);
1602         QImage expected(expectedFile);
1603
1604         // Verifies that pngdumper generated image is not a null size image
1605         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1606
1607         ImageCompare compare;
1608
1609         // Verifies that actual and expected images have the same size
1610         QCOMPARE(compare.CompareSizes(actual, expected), true);
1611
1612         // Verifies that actual and expected images are pixel-wise the same
1613         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1614     }
1615 }
1616 void tst_imagecompare::recursiveBlur_varRadius(){
1617     QStringList filters;
1618     filters << "RecursiveBlur_radius*.png";
1619     actualDir.setNameFilters(filters);
1620     QStringList list = actualDir.entryList();
1621
1622     for (int i = 0; i < list.size(); ++i){
1623         QString filename = list.at(i).toLocal8Bit().constData();
1624         qDebug() << "Testing shader image " + filename;
1625         QString actualFile = actualDir.absolutePath() + "/" + filename;
1626         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1627
1628         QImage actual(actualFile);
1629         QImage expected(expectedFile);
1630
1631         // Verifies that pngdumper generated image is not a null size image
1632         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1633
1634         ImageCompare compare;
1635
1636         // Verifies that actual and expected images have the same size
1637         QCOMPARE(compare.CompareSizes(actual, expected), true);
1638
1639         // Verifies that actual and expected images are pixel-wise the same
1640         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1641     }
1642 }
1643 void tst_imagecompare::recursiveBlur_varTransparentBorder(){
1644     QStringList filters;
1645     filters << "RecursiveBlur_transparentBorder*.png";
1646     actualDir.setNameFilters(filters);
1647     QStringList list = actualDir.entryList();
1648
1649     for (int i = 0; i < list.size(); ++i){
1650         QString filename = list.at(i).toLocal8Bit().constData();
1651         qDebug() << "Testing shader image " + filename;
1652         QString actualFile = actualDir.absolutePath() + "/" + filename;
1653         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1654
1655         QImage actual(actualFile);
1656         QImage expected(expectedFile);
1657
1658         // Verifies that pngdumper generated image is not a null size image
1659         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1660
1661         ImageCompare compare;
1662
1663         // Verifies that actual and expected images have the same size
1664         QCOMPARE(compare.CompareSizes(actual, expected), true);
1665
1666         // Verifies that actual and expected images are pixel-wise the same
1667         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1668     }
1669 }
1670
1671 void tst_imagecompare::thresholdMask_varSpread(){
1672     QStringList filters;
1673     filters << "ThresholdMask_spread*.png";
1674     actualDir.setNameFilters(filters);
1675     QStringList list = actualDir.entryList();
1676
1677     for (int i = 0; i < list.size(); ++i){
1678         QString filename = list.at(i).toLocal8Bit().constData();
1679         qDebug() << "Testing shader image " + filename;
1680         QString actualFile = actualDir.absolutePath() + "/" + filename;
1681         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1682
1683         QImage actual(actualFile);
1684         QImage expected(expectedFile);
1685
1686         // Verifies that pngdumper generated image is not a null size image
1687         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1688
1689         ImageCompare compare;
1690
1691         // Verifies that actual and expected images have the same size
1692         QCOMPARE(compare.CompareSizes(actual, expected), true);
1693
1694         // Verifies that actual and expected images are pixel-wise the same
1695         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1696     }
1697 }
1698 void tst_imagecompare::thresholdMask_varThreshold(){
1699     QStringList filters;
1700     filters << "ThresholdMask_threshold*.png";
1701     actualDir.setNameFilters(filters);
1702     QStringList list = actualDir.entryList();
1703
1704     for (int i = 0; i < list.size(); ++i){
1705         QString filename = list.at(i).toLocal8Bit().constData();
1706         qDebug() << "Testing shader image " + filename;
1707         QString actualFile = actualDir.absolutePath() + "/" + filename;
1708         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1709
1710         QImage actual(actualFile);
1711         QImage expected(expectedFile);
1712
1713         // Verifies that pngdumper generated image is not a null size image
1714         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1715
1716         ImageCompare compare;
1717
1718         // Verifies that actual and expected images have the same size
1719         QCOMPARE(compare.CompareSizes(actual, expected), true);
1720
1721         // Verifies that actual and expected images are pixel-wise the same
1722         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1723     }
1724 }
1725
1726 void tst_imagecompare::radialBlur_varAngle(){
1727     QStringList filters;
1728     filters << "RadialBlur_angle*.png";
1729     actualDir.setNameFilters(filters);
1730     QStringList list = actualDir.entryList();
1731
1732     for (int i = 0; i < list.size(); ++i){
1733         QString filename = list.at(i).toLocal8Bit().constData();
1734         qDebug() << "Testing shader image " + filename;
1735         QString actualFile = actualDir.absolutePath() + "/" + filename;
1736         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1737
1738         QImage actual(actualFile);
1739         QImage expected(expectedFile);
1740
1741         // Verifies that pngdumper generated image is not a null size image
1742         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1743
1744         ImageCompare compare;
1745
1746         // Verifies that actual and expected images have the same size
1747         QCOMPARE(compare.CompareSizes(actual, expected), true);
1748
1749         // Verifies that actual and expected images are pixel-wise the same
1750         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1751     }
1752 }
1753 void tst_imagecompare::radialBlur_varHorizontalOffset(){
1754     QStringList filters;
1755     filters << "RadialBlur_horizontalOffset*.png";
1756     actualDir.setNameFilters(filters);
1757     QStringList list = actualDir.entryList();
1758
1759     for (int i = 0; i < list.size(); ++i){
1760         QString filename = list.at(i).toLocal8Bit().constData();
1761         qDebug() << "Testing shader image " + filename;
1762         QString actualFile = actualDir.absolutePath() + "/" + filename;
1763         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1764
1765         QImage actual(actualFile);
1766         QImage expected(expectedFile);
1767
1768         // Verifies that pngdumper generated image is not a null size image
1769         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1770
1771         ImageCompare compare;
1772
1773         // Verifies that actual and expected images have the same size
1774         QCOMPARE(compare.CompareSizes(actual, expected), true);
1775
1776         // Verifies that actual and expected images are pixel-wise the same
1777         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1778     }
1779 }
1780 void tst_imagecompare::radialBlur_varVerticalOffset(){
1781     QStringList filters;
1782     filters << "RadialBlur_verticalOffset*.png";
1783     actualDir.setNameFilters(filters);
1784     QStringList list = actualDir.entryList();
1785
1786     for (int i = 0; i < list.size(); ++i){
1787         QString filename = list.at(i).toLocal8Bit().constData();
1788         qDebug() << "Testing shader image " + filename;
1789         QString actualFile = actualDir.absolutePath() + "/" + filename;
1790         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1791
1792         QImage actual(actualFile);
1793         QImage expected(expectedFile);
1794
1795         // Verifies that pngdumper generated image is not a null size image
1796         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1797
1798         ImageCompare compare;
1799
1800         // Verifies that actual and expected images have the same size
1801         QCOMPARE(compare.CompareSizes(actual, expected), true);
1802
1803         // Verifies that actual and expected images are pixel-wise the same
1804         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1805     }
1806 }
1807
1808 void tst_imagecompare::directionalBlur_varAngle(){
1809     QStringList filters;
1810     filters << "DirectionalBlur_angle*.png";
1811     actualDir.setNameFilters(filters);
1812     QStringList list = actualDir.entryList();
1813
1814     for (int i = 0; i < list.size(); ++i){
1815         QString filename = list.at(i).toLocal8Bit().constData();
1816         qDebug() << "Testing shader image " + filename;
1817         QString actualFile = actualDir.absolutePath() + "/" + filename;
1818         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1819
1820         QImage actual(actualFile);
1821         QImage expected(expectedFile);
1822
1823         // Verifies that pngdumper generated image is not a null size image
1824         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1825
1826         ImageCompare compare;
1827
1828         // Verifies that actual and expected images have the same size
1829         QCOMPARE(compare.CompareSizes(actual, expected), true);
1830
1831         // Verifies that actual and expected images are pixel-wise the same
1832         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1833     }
1834 }
1835 void tst_imagecompare::directionalBlur_varLength(){
1836     QStringList filters;
1837     filters << "DirectionalBlur_length*.png";
1838     actualDir.setNameFilters(filters);
1839     QStringList list = actualDir.entryList();
1840
1841     for (int i = 0; i < list.size(); ++i){
1842         QString filename = list.at(i).toLocal8Bit().constData();
1843         qDebug() << "Testing shader image " + filename;
1844         QString actualFile = actualDir.absolutePath() + "/" + filename;
1845         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1846
1847         QImage actual(actualFile);
1848         QImage expected(expectedFile);
1849
1850         // Verifies that pngdumper generated image is not a null size image
1851         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1852
1853         ImageCompare compare;
1854
1855         // Verifies that actual and expected images have the same size
1856         QCOMPARE(compare.CompareSizes(actual, expected), true);
1857
1858         // Verifies that actual and expected images are pixel-wise the same
1859         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1860     }
1861 }
1862
1863 void tst_imagecompare::zoomBlur_varHorizontalOffset(){
1864     QStringList filters;
1865     filters << "ZoomBlur_horizontalOffset*.png";
1866     actualDir.setNameFilters(filters);
1867     QStringList list = actualDir.entryList();
1868
1869     for (int i = 0; i < list.size(); ++i){
1870         QString filename = list.at(i).toLocal8Bit().constData();
1871         qDebug() << "Testing shader image " + filename;
1872         QString actualFile = actualDir.absolutePath() + "/" + filename;
1873         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1874
1875         QImage actual(actualFile);
1876         QImage expected(expectedFile);
1877
1878         // Verifies that pngdumper generated image is not a null size image
1879         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1880
1881         ImageCompare compare;
1882
1883         // Verifies that actual and expected images have the same size
1884         QCOMPARE(compare.CompareSizes(actual, expected), true);
1885
1886         // Verifies that actual and expected images are pixel-wise the same
1887         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1888     }
1889 }
1890 void tst_imagecompare::zoomBlur_varVerticalOffset(){
1891     QStringList filters;
1892     filters << "ZoomBlur_verticalOffset*.png";
1893     actualDir.setNameFilters(filters);
1894     QStringList list = actualDir.entryList();
1895
1896     for (int i = 0; i < list.size(); ++i){
1897         QString filename = list.at(i).toLocal8Bit().constData();
1898         qDebug() << "Testing shader image " + filename;
1899         QString actualFile = actualDir.absolutePath() + "/" + filename;
1900         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1901
1902         QImage actual(actualFile);
1903         QImage expected(expectedFile);
1904
1905         // Verifies that pngdumper generated image is not a null size image
1906         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1907
1908         ImageCompare compare;
1909
1910         // Verifies that actual and expected images have the same size
1911         QCOMPARE(compare.CompareSizes(actual, expected), true);
1912
1913         // Verifies that actual and expected images are pixel-wise the same
1914         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1915     }
1916 }
1917 void tst_imagecompare::zoomBlur_varLength(){
1918     QStringList filters;
1919     filters << "ZoomBlur_length*.png";
1920     actualDir.setNameFilters(filters);
1921     QStringList list = actualDir.entryList();
1922
1923     for (int i = 0; i < list.size(); ++i){
1924         QString filename = list.at(i).toLocal8Bit().constData();
1925         qDebug() << "Testing shader image " + filename;
1926         QString actualFile = actualDir.absolutePath() + "/" + filename;
1927         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1928
1929         QImage actual(actualFile);
1930         QImage expected(expectedFile);
1931
1932         // Verifies that pngdumper generated image is not a null size image
1933         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1934
1935         ImageCompare compare;
1936
1937         // Verifies that actual and expected images have the same size
1938         QCOMPARE(compare.CompareSizes(actual, expected), true);
1939
1940         // Verifies that actual and expected images are pixel-wise the same
1941         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1942     }
1943 }
1944
1945 void tst_imagecompare::levelAdjust_varMinimumInput(){
1946     QStringList filters;
1947     filters << "LevelAdjust_minimumInput*.png";
1948     actualDir.setNameFilters(filters);
1949     QStringList list = actualDir.entryList();
1950
1951     for (int i = 0; i < list.size(); ++i){
1952         QString filename = list.at(i).toLocal8Bit().constData();
1953         qDebug() << "Testing shader image " + filename;
1954         QString actualFile = actualDir.absolutePath() + "/" + filename;
1955         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1956
1957         QImage actual(actualFile);
1958         QImage expected(expectedFile);
1959
1960         // Verifies that pngdumper generated image is not a null size image
1961         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1962
1963         ImageCompare compare;
1964
1965         // Verifies that actual and expected images have the same size
1966         QCOMPARE(compare.CompareSizes(actual, expected), true);
1967
1968         // Verifies that actual and expected images are pixel-wise the same
1969         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1970     }
1971 }
1972 void tst_imagecompare::levelAdjust_varMaximumInput(){
1973     QStringList filters;
1974     filters << "LevelAdjust_maximumInput*.png";
1975     actualDir.setNameFilters(filters);
1976     QStringList list = actualDir.entryList();
1977
1978     for (int i = 0; i < list.size(); ++i){
1979         QString filename = list.at(i).toLocal8Bit().constData();
1980         qDebug() << "Testing shader image " + filename;
1981         QString actualFile = actualDir.absolutePath() + "/" + filename;
1982         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
1983
1984         QImage actual(actualFile);
1985         QImage expected(expectedFile);
1986
1987         // Verifies that pngdumper generated image is not a null size image
1988         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
1989
1990         ImageCompare compare;
1991
1992         // Verifies that actual and expected images have the same size
1993         QCOMPARE(compare.CompareSizes(actual, expected), true);
1994
1995         // Verifies that actual and expected images are pixel-wise the same
1996         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
1997     }
1998 }
1999 void tst_imagecompare::levelAdjust_varMinimumOutput(){
2000     QStringList filters;
2001     filters << "LevelAdjust_minimumOutput*.png";
2002     actualDir.setNameFilters(filters);
2003     QStringList list = actualDir.entryList();
2004
2005     for (int i = 0; i < list.size(); ++i){
2006         QString filename = list.at(i).toLocal8Bit().constData();
2007         qDebug() << "Testing shader image " + filename;
2008         QString actualFile = actualDir.absolutePath() + "/" + filename;
2009         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
2010
2011         QImage actual(actualFile);
2012         QImage expected(expectedFile);
2013
2014         // Verifies that pngdumper generated image is not a null size image
2015         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
2016
2017         ImageCompare compare;
2018
2019         // Verifies that actual and expected images have the same size
2020         QCOMPARE(compare.CompareSizes(actual, expected), true);
2021
2022         // Verifies that actual and expected images are pixel-wise the same
2023         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
2024     }
2025 }
2026 void tst_imagecompare::levelAdjust_varMaximumOutput(){
2027     QStringList filters;
2028     filters << "LevelAdjust_maximumOutput*.png";
2029     actualDir.setNameFilters(filters);
2030     QStringList list = actualDir.entryList();
2031
2032     for (int i = 0; i < list.size(); ++i){
2033         QString filename = list.at(i).toLocal8Bit().constData();
2034         qDebug() << "Testing shader image " + filename;
2035         QString actualFile = actualDir.absolutePath() + "/" + filename;
2036         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
2037
2038         QImage actual(actualFile);
2039         QImage expected(expectedFile);
2040
2041         // Verifies that pngdumper generated image is not a null size image
2042         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
2043
2044         ImageCompare compare;
2045
2046         // Verifies that actual and expected images have the same size
2047         QCOMPARE(compare.CompareSizes(actual, expected), true);
2048
2049         // Verifies that actual and expected images are pixel-wise the same
2050         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
2051     }
2052 }
2053
2054 void tst_imagecompare::maskedBlur_varRadius(){
2055     QStringList filters;
2056     filters << "MaskedBlur_radius*.png";
2057     actualDir.setNameFilters(filters);
2058     QStringList list = actualDir.entryList();
2059
2060     for (int i = 0; i < list.size(); ++i){
2061         QString filename = list.at(i).toLocal8Bit().constData();
2062         qDebug() << "Testing shader image " + filename;
2063         QString actualFile = actualDir.absolutePath() + "/" + filename;
2064         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
2065
2066         QImage actual(actualFile);
2067         QImage expected(expectedFile);
2068
2069         // Verifies that pngdumper generated image is not a null size image
2070         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
2071
2072         ImageCompare compare;
2073
2074         // Verifies that actual and expected images have the same size
2075         QCOMPARE(compare.CompareSizes(actual, expected), true);
2076
2077         // Verifies that actual and expected images are pixel-wise the same
2078         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
2079     }
2080 }
2081 void tst_imagecompare::maskedBlur_varFast(){
2082     QStringList filters;
2083     filters << "MaskedBlur_fast*.png";
2084     actualDir.setNameFilters(filters);
2085     QStringList list = actualDir.entryList();
2086
2087     for (int i = 0; i < list.size(); ++i){
2088         QString filename = list.at(i).toLocal8Bit().constData();
2089         qDebug() << "Testing shader image " + filename;
2090         QString actualFile = actualDir.absolutePath() + "/" + filename;
2091         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
2092
2093         QImage actual(actualFile);
2094         QImage expected(expectedFile);
2095
2096         // Verifies that pngdumper generated image is not a null size image
2097         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
2098
2099         ImageCompare compare;
2100
2101         // Verifies that actual and expected images have the same size
2102         QCOMPARE(compare.CompareSizes(actual, expected), true);
2103
2104         // Verifies that actual and expected images are pixel-wise the same
2105         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
2106     }
2107 }
2108 void tst_imagecompare::maskedBlur_varTransparentBorder(){
2109     QStringList filters;
2110     filters << "MaskedBlur_transparentBorder*.png";
2111     actualDir.setNameFilters(filters);
2112     QStringList list = actualDir.entryList();
2113
2114     for (int i = 0; i < list.size(); ++i){
2115         QString filename = list.at(i).toLocal8Bit().constData();
2116         qDebug() << "Testing shader image " + filename;
2117         QString actualFile = actualDir.absolutePath() + "/" + filename;
2118         QString expectedFile = expectedDir.absolutePath() + "/" + filename;
2119
2120         QImage actual(actualFile);
2121         QImage expected(expectedFile);
2122
2123         // Verifies that pngdumper generated image is not a null size image
2124         QCOMPARE((actual.width() != 0 || actual.height() != 0), true);
2125
2126         ImageCompare compare;
2127
2128         // Verifies that actual and expected images have the same size
2129         QCOMPARE(compare.CompareSizes(actual, expected), true);
2130
2131         // Verifies that actual and expected images are pixel-wise the same
2132         QCOMPARE(compare.ComparePixels(actual, expected, diffTolerance, filename), true);
2133     }
2134 }