File indexing completed on 2024-07-14 04:37:03

0001 // SPDX-FileCopyrightText: Lukas Sommer <sommerluk@gmail.com>
0002 // SPDX-License-Identifier: BSD-2-Clause OR MIT
0003 
0004 // First included header is the public header of the class we are testing;
0005 // this forces the header to be self-contained.
0006 #include "colordialog.h"
0007 // Second, the private implementation.
0008 #include "colordialog_p.h" // IWYU pragma: keep
0009 
0010 #include "absolutecolor.h"
0011 #include "chromahuediagram.h"
0012 #include "colorpatch.h"
0013 #include "constpropagatinguniquepointer.h"
0014 #include "genericcolor.h"
0015 #include "gradientslider.h"
0016 #include "helperconversion.h"
0017 #include "helperqttypes.h"
0018 #include "initializetranslation.h"
0019 #include "lchadouble.h"
0020 #include "lchdouble.h"
0021 #include "multispinbox.h"
0022 #include "rgbcolor.h"
0023 #include "rgbcolorspace.h"
0024 #include "rgbcolorspacefactory.h"
0025 #include "settranslation.h"
0026 #include "wheelcolorpicker.h"
0027 #include <qaction.h>
0028 #include <qapplication.h>
0029 #include <qbenchmark.h>
0030 #include <qbytearray.h>
0031 #include <qcolor.h>
0032 #include <qcolordialog.h>
0033 #include <qcoreapplication.h>
0034 #include <qcoreevent.h>
0035 #include <qdebug.h>
0036 #include <qglobal.h>
0037 #include <qhash.h>
0038 #include <qlineedit.h>
0039 #include <qlist.h>
0040 #include <qlocale.h>
0041 #include <qmetaobject.h>
0042 #include <qnamespace.h>
0043 #include <qobject.h>
0044 #include <qpair.h>
0045 #include <qpointer.h>
0046 #include <qpushbutton.h>
0047 #include <qscopedpointer.h>
0048 #include <qsharedpointer.h>
0049 #include <qsignalspy.h>
0050 #include <qspinbox.h>
0051 #include <qstringbuilder.h>
0052 #include <qstringliteral.h>
0053 #include <qtabwidget.h>
0054 #include <qtemporaryfile.h>
0055 #include <qtest.h>
0056 #include <qtestcase.h>
0057 #include <qtestdata.h>
0058 #include <qtestkeyboard.h>
0059 #include <qwidget.h>
0060 #include <type_traits>
0061 
0062 #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
0063 #include <qcontainerfwd.h>
0064 #include <qobjectdefs.h>
0065 #include <qstring.h>
0066 #include <qtmetamacros.h>
0067 #include <utility>
0068 #else
0069 #include <qobjectdefs.h>
0070 #include <qstring.h>
0071 #include <qstringlist.h>
0072 #include <qvector.h>
0073 #include <utility>
0074 #endif
0075 
0076 // From Qt documentation:
0077 //     “Note: This function is not declared in any of Qt's header files. To
0078 //      use it in your application, declare the function prototype before
0079 //      calling it.”
0080 void qt_set_sequence_auto_mnemonic(bool b);
0081 
0082 class TestColorDialogSnippetClass : public QWidget
0083 {
0084     Q_OBJECT
0085 public Q_SLOTS:
0086     void mySlot(QColor color)
0087     {
0088         Q_UNUSED(color)
0089     }
0090 
0091 public:
0092     // A constructor that is clazy-conform
0093     explicit TestColorDialogSnippetClass(QWidget *parent = nullptr)
0094         : QWidget(parent)
0095     {
0096     }
0097 
0098     void testSnippet05()
0099     {
0100         //! [ColorDialog Open]
0101         PerceptualColor::ColorDialog *m_dialog = //
0102             new PerceptualColor::ColorDialog( //
0103                 PerceptualColor::RgbColorSpaceFactory::createSrgb());
0104         m_dialog->open(this, SLOT(mySlot(QColor)));
0105         //! [ColorDialog Open]
0106         delete m_dialog;
0107     }
0108 };
0109 
0110 static void snippet01()
0111 {
0112     // This function will not be called in the unit tests because getColor()
0113     // does not return without user interaction!
0114     //! [ColorDialog Get color with alpha channel]
0115     QColor myColor = PerceptualColor::ColorDialog::getColor(
0116         // Current color at widget startup:
0117         Qt::green,
0118         // Parent widget (or nullptr for no parent):
0119         nullptr,
0120         // Window title (or an empty string for default title):
0121         QStringLiteral("Window title"),
0122         // Options:
0123         PerceptualColor::ColorDialog::ColorDialogOption::ShowAlphaChannel);
0124     //! [ColorDialog Get color with alpha channel]
0125     Q_UNUSED(myColor)
0126 }
0127 
0128 static void snippet02()
0129 {
0130     //! [setOptionsWithLocalEnum]
0131     auto myDialog = new PerceptualColor::ColorDialog();
0132     myDialog->setOption( //
0133         PerceptualColor::ColorDialog::ColorDialogOption::ShowAlphaChannel,
0134         false);
0135     //! [setOptionsWithLocalEnum]
0136     QCOMPARE( //
0137         myDialog->testOption( //
0138             PerceptualColor::ColorDialog::ColorDialogOption::ShowAlphaChannel), //
0139         false);
0140     delete myDialog;
0141 }
0142 
0143 static void snippet03()
0144 {
0145     //! [setOptionsWithQColorDialogEnum]
0146     auto myDialog = new PerceptualColor::ColorDialog();
0147     myDialog->setOption(QColorDialog::ShowAlphaChannel, false);
0148     //! [setOptionsWithQColorDialogEnum]
0149     QCOMPARE( //
0150         myDialog->testOption( //
0151             PerceptualColor::ColorDialog::ColorDialogOption::ShowAlphaChannel), //
0152         false);
0153     delete myDialog;
0154 }
0155 
0156 static void snippet04()
0157 {
0158     // This function will not be called in the unit tests because getColor()
0159     // does not return without user interaction!
0160     //! [ColorDialog Get color]
0161     // Show a modal color dialog and get the color that the user has chosen
0162     QColor myColor = PerceptualColor::ColorDialog::getColor();
0163     //! [ColorDialog Get color]
0164     Q_UNUSED(myColor)
0165 }
0166 
0167 namespace PerceptualColor
0168 {
0169 class TestColorDialog : public QObject
0170 {
0171     Q_OBJECT
0172 
0173 public:
0174     explicit TestColorDialog(QObject *parent = nullptr)
0175         : QObject(parent)
0176     {
0177     }
0178 
0179 private:
0180     QScopedPointer<ColorDialog> m_perceptualDialog;
0181     QScopedPointer<ColorDialog> m_perceptualDialog2;
0182     QScopedPointer<QColorDialog> m_qDialog;
0183     QScopedPointer<QColorDialog> m_qDialog2;
0184     QColor m_color;
0185     QSharedPointer<RgbColorSpace> m_srgbBuildinColorSpace = //
0186         RgbColorSpaceFactory::createSrgb();
0187 
0188     static void voidMessageHandler(QtMsgType, const QMessageLogContext &, const QString &)
0189     {
0190         // dummy message handler that does not print messages
0191     }
0192 
0193     void helperProvideQColors()
0194     {
0195         // suppress warning for generating invalid QColor
0196         qInstallMessageHandler(voidMessageHandler);
0197 
0198         QTest::addColumn<QColor>("color");
0199 
0200         QTest::newRow("RGB 1 2 3") //
0201             << QColor(1, 2, 3);
0202         QTest::newRow("RGBA 1 2 3 4") //
0203             << QColor(1, 2, 3, 4);
0204         QTest::newRow("RGB 1 2 300") //
0205             << QColor(1, 2, 300);
0206         QTest::newRow("RGB 1 2 -300") //
0207             << QColor(1, 2, -300);
0208         QTest::newRow("RGBA 1 2 300 4") //
0209             << QColor(1, 2, 300, 4);
0210         QTest::newRow("RGBA 1 2 3 400") //
0211             << QColor(1, 2, 3, 400);
0212         QTest::newRow("RGBA 1 2 3 -400") //
0213             << QColor(1, 2, 3, -400);
0214 
0215         QTest::newRow("RGB 0.1 0.2 0.3") //
0216             << QColor::fromRgbF(0.1f, 0.2f, 0.3f);
0217         QTest::newRow("RGBA 0.1 0.2 0.3 0.4") //
0218             << QColor::fromRgbF(0.1f, 0.2f, 0.3f, 0.4f);
0219         QTest::newRow("RGB 0.1 6.2 0.300") //
0220             << QColor::fromRgbF(0.1f, 6.2f, 0.300f);
0221         QTest::newRow("RGBA 0.1 6.2 0.300 0.4") //
0222             << QColor::fromRgbF(0.1f, 6.2f, 0.300f, 0.4f);
0223         QTest::newRow("RGBA 0.1 0.2 0.3 -0.4") //
0224             << QColor::fromRgbF(0.1f, 0.2f, 0.3f, -0.4f);
0225         QTest::newRow("RGBA 0.1 0.2 0.3 400") //
0226             << QColor::fromRgbF(0.1f, 0.2f, 0.3f, 400);
0227 
0228         QTest::newRow("CMYK 1 2 3 4") //
0229             << QColor::fromCmyk(1, 2, 3, 4);
0230         QTest::newRow("CMYK 1 2 3 4 5") //
0231             << QColor::fromCmyk(1, 2, 3, 4, 5);
0232         QTest::newRow("CMYK 1 2 300 4") //
0233             << QColor::fromCmyk(1, 2, 300, 4);
0234         QTest::newRow("CMYK 1 2 300 4 5") //
0235             << QColor::fromCmyk(1, 2, 300, 4, 5);
0236         QTest::newRow("CMYK 0.1 0.2 0.300 0.4") //
0237             << QColor::fromCmykF(0.1f, 0.2f, 0.300f, 0.4f);
0238         QTest::newRow("CMYK 0.1 0.2 0.300 0.4 0.6495217645") //
0239             << QColor::fromCmykF(0.1f, 0.2f, 0.300f, 0.4f, 0.6495217645f);
0240         QTest::newRow("CMYK 0.1 6.2 0.300 0.4") //
0241             << QColor::fromCmykF(0.1f, 6.2f, 0.300f, 0.4f);
0242         QTest::newRow("CMYK 0.1 -6.2 0.300 0.4") //
0243             << QColor::fromCmykF(0.1f, -6.2f, 0.300f, 0.4f);
0244         QTest::newRow("CMYK 0.1 6.2 0.300 0.4 0.6495217645") //
0245             << QColor::fromCmykF(0.1f, 6.2f, 0.300f, 0.4f, 0.6495217645f);
0246         QTest::newRow("CMYK 0.1 6.2 0.300 0.4 -0.6495217645") //
0247             << QColor::fromCmykF(0.1f, 6.2f, 0.300f, 0.4f, -0.6495217645f);
0248 
0249         QTest::newRow("HSL 2 3 4") //
0250             << QColor::fromHsl(2, 3, 4);
0251         QTest::newRow("HSL 2 3 4 5") //
0252             << QColor::fromHsl(2, 3, 4, 5);
0253         QTest::newRow("HSL 2 300 4") //
0254             << QColor::fromHsl(2, 300, 4);
0255         QTest::newRow("HSL 2 300 4 5") //
0256             << QColor::fromHsl(2, 300, 4, 5);
0257         QTest::newRow("HSL 0.2 0.300 0.4") //
0258             << QColor::fromHslF(0.2f, 0.300f, 0.4f);
0259         QTest::newRow("HSL 0.2 0.300 0.4 0.6495217645") //
0260             << QColor::fromHslF(0.2f, 0.300f, 0.4f, 0.6495217645f);
0261         QTest::newRow("HSL 6.2 0.300 0.4") //
0262             << QColor::fromHslF(6.2f, 0.300f, 0.4f);
0263         QTest::newRow("HSL -6.2 0.300 0.4") //
0264             << QColor::fromHslF(-6.2f, 0.300f, 0.4f);
0265         QTest::newRow("HSL 6.2 0.300 0.4 0.6495217645") //
0266             << QColor::fromHslF(6.2f, 0.300f, 0.4f, 0.6495217645f);
0267         QTest::newRow("HSL 6.2 0.300 0.4 -0.6495217645") //
0268             << QColor::fromHslF(6.2f, 0.300f, 0.4f, -0.6495217645f);
0269         QTest::newRow("HSL 6.2 0.300 0.4 1.6495217645") //
0270             << QColor::fromHslF(6.2f, 0.300f, 0.4f, 1.6495217645f);
0271 
0272         QTest::newRow("HSV 2 3 4") //
0273             << QColor::fromHsv(2, 3, 4);
0274         QTest::newRow("HSV 2 3 4 5") //
0275             << QColor::fromHsv(2, 3, 4, 5);
0276         QTest::newRow("HSV 2 300 4") //
0277             << QColor::fromHsv(2, 300, 4);
0278         QTest::newRow("HSV 2 300 4 5") //
0279             << QColor::fromHsv(2, 300, 4, 5);
0280         QTest::newRow("HSV 0.2 0.300 0.4") //
0281             << QColor::fromHsvF(0.2f, 0.300f, 0.4f);
0282         QTest::newRow("HSV 0.2 0.300 0.4 0.6495217645") //
0283             << QColor::fromHsvF(0.2f, 0.300f, 0.4f, 0.6495217645f);
0284         QTest::newRow("HSV 6.2 0.300 0.4") //
0285             << QColor::fromHsvF(6.2f, 0.300f, 0.4f);
0286         QTest::newRow("HSV -6.2 0.300 0.4") //
0287             << QColor::fromHsvF(-6.2f, 0.300f, 0.4f);
0288         QTest::newRow("HSV 6.2 0.300 0.4 0.6495217645") //
0289             << QColor::fromHsvF(6.2f, 0.300f, 0.4f, 0.6495217645f);
0290         QTest::newRow("HSV 6.2 0.300 0.4 -0.6495217645") //
0291             << QColor::fromHsvF(6.2f, 0.300f, 0.4f, -0.6495217645f);
0292         QTest::newRow("HSV 6.2 0.300 0.4 1.6495217645") //
0293             << QColor::fromHsvF(6.2f, 0.300f, 0.4f, 1.6495217645f);
0294 
0295         QTest::newRow("invalid") << QColor();
0296 
0297         // do not suppress warning for generating invalid QColor anymore
0298         qInstallMessageHandler(nullptr);
0299     }
0300 
0301     void helperCompareDialog(ColorDialog *perceptualDialog, QColorDialog *qColorDialog)
0302     {
0303         // Compare the state of perceptualDialog (actual)
0304         // to qColorDialog (expected)
0305         const QColor perceptualDialogSelected = //
0306             perceptualDialog->selectedColor();
0307         const QColor qColorDialogSelected = qColorDialog->selectedColor();
0308         QCOMPARE( //
0309             perceptualDialogSelected.name(), //
0310             qColorDialogSelected.name());
0311         QCOMPARE( //
0312             perceptualDialogSelected.alpha(), //
0313             qColorDialogSelected.alpha());
0314         QCOMPARE(perceptualDialogSelected.spec(), //
0315                  qColorDialogSelected.spec());
0316         const QColor perceptualDialogCurrent = perceptualDialog->currentColor();
0317         const QColor qColorDialogCurrent = qColorDialog->currentColor();
0318         QCOMPARE(perceptualDialogCurrent.name(), qColorDialogCurrent.name());
0319         QCOMPARE(perceptualDialogCurrent.alpha(), qColorDialogCurrent.alpha());
0320         QCOMPARE(perceptualDialogCurrent.spec(), qColorDialogCurrent.spec());
0321         QCOMPARE(perceptualDialog->testOption(QColorDialog::NoButtons), //
0322                  qColorDialog->testOption(QColorDialog::NoButtons));
0323         QCOMPARE( //
0324             perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
0325             qColorDialog->testOption(QColorDialog::ShowAlphaChannel));
0326         QCOMPARE( //
0327             perceptualDialog->options().testFlag(QColorDialog::NoButtons), //
0328             qColorDialog->options().testFlag(QColorDialog::NoButtons));
0329         QCOMPARE( //
0330             perceptualDialog->options().testFlag(QColorDialog::ShowAlphaChannel),
0331             qColorDialog->options().testFlag(QColorDialog::ShowAlphaChannel));
0332         QCOMPARE(perceptualDialog->isVisible(), qColorDialog->isVisible());
0333         QCOMPARE(perceptualDialog->isModal(), qColorDialog->isModal());
0334         QCOMPARE(perceptualDialog->result(), qColorDialog->result());
0335         QCOMPARE(perceptualDialog->parent(), qColorDialog->parent());
0336         QCOMPARE(perceptualDialog->parentWidget(), //
0337                  qColorDialog->parentWidget());
0338     }
0339 
0340 private Q_SLOTS:
0341     // This is just a helper slot, not an actual test.
0342     // It is neither called by QTest (because it has a parameter).
0343     void helperReceiveSignals(QColor color)
0344     {
0345         m_color = color;
0346     }
0347 
0348     void initTestCase()
0349     {
0350         // Called before the first test function is executed
0351     }
0352 
0353     void cleanupTestCase()
0354     {
0355         // Called after the last test function was executed
0356     }
0357 
0358     void init()
0359     {
0360         // Called before each test function is executed
0361 
0362         // Make sure to have mnemonics (like Qt::ALT+Qt::Key_X for "E&xit")
0363         // enabled, also on platforms that disable it by default.
0364         qt_set_sequence_auto_mnemonic(true);
0365     }
0366 
0367     void cleanup()
0368     {
0369         // Called after every test function
0370     }
0371 
0372     void testDefaultConstructorAndDestructor1()
0373     {
0374         // This should not crash!
0375         ColorDialog test(m_srgbBuildinColorSpace);
0376         Q_UNUSED(test);
0377     }
0378 
0379     void testDefaultConstructorAndDestructor2()
0380     {
0381         // This should not crash!
0382         ColorDialog test;
0383         Q_UNUSED(test);
0384     }
0385 
0386     void testDefaultConstructorAndDestructor3()
0387     {
0388         QWidget myWidget;
0389         {
0390             // This should not crash!
0391             ColorDialog test(m_srgbBuildinColorSpace, &myWidget);
0392             Q_UNUSED(test);
0393         }
0394     }
0395 
0396     void testDefaultConstructorAndDestructor4()
0397     {
0398         QWidget myWidget;
0399         {
0400             // This should not crash!
0401             ColorDialog test(&myWidget);
0402             Q_UNUSED(test);
0403         }
0404     }
0405 
0406     void testConstructorQWidget()
0407     {
0408         // Test the constructor ColorDialog(QWidget * parent = nullptr)
0409         m_perceptualDialog.reset( //
0410             new ColorDialog(m_srgbBuildinColorSpace));
0411         QScopedPointer<QWidget> tempWidget{new QWidget()};
0412         QScopedPointer<ColorDialog> tempPerceptualDialog2;
0413         tempPerceptualDialog2.reset( //
0414             new ColorDialog(m_srgbBuildinColorSpace, tempWidget.data()));
0415         QCOMPARE(tempPerceptualDialog2->parentWidget(), tempWidget.data());
0416         QCOMPARE(tempPerceptualDialog2->parent(), tempWidget.data());
0417     }
0418 
0419     void testConstructorQWidgetConformance()
0420     {
0421         // Test the constructor
0422         m_perceptualDialog.reset( //
0423             new ColorDialog( //
0424                 m_srgbBuildinColorSpace, //
0425                 QColor(Qt::white) //
0426                 ) //
0427         );
0428         QScopedPointer<QWidget> tempWidget{new QWidget()};
0429         ColorDialog *tempPerceptualDialog2 = //
0430             new ColorDialog( //
0431                 m_srgbBuildinColorSpace,
0432                 QColor(Qt::white), //
0433                 tempWidget.data() //
0434             );
0435         // Test if this coordinates is conform to QColorDialog
0436         m_qDialog.reset(new QColorDialog());
0437         QColorDialog *tempQDialog2 = new QColorDialog(tempWidget.data());
0438         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0439         helperCompareDialog(tempPerceptualDialog2, tempQDialog2);
0440     }
0441 
0442     void testConstructorQColorQWidget_data()
0443     {
0444         helperProvideQColors();
0445     }
0446 
0447     void testConstructorQColorQWidget()
0448     {
0449         QFETCH(QColor, color);
0450         QColor colorOpaque;
0451         if (color.isValid()) {
0452             colorOpaque = color.toRgb();
0453             colorOpaque.setAlpha(255);
0454         } else {
0455             colorOpaque = Qt::black;
0456         }
0457 
0458         // Test the constructors
0459         m_perceptualDialog.reset( //
0460             new ColorDialog(m_srgbBuildinColorSpace, color));
0461         QScopedPointer<QWidget> tempWidget{new QWidget()};
0462         QScopedPointer<ColorDialog> tempPerceptualDialog2{
0463             //
0464             new ColorDialog( //
0465                 m_srgbBuildinColorSpace, //
0466                 color, //
0467                 tempWidget.data() //
0468                 ) //
0469         };
0470 
0471         // Test post-condition: currentColor() is color
0472         QCOMPARE(m_perceptualDialog->currentColor().name(), //
0473                  colorOpaque.name());
0474         QCOMPARE(m_perceptualDialog->currentColor().alpha(), //
0475                  colorOpaque.alpha());
0476         QCOMPARE(m_perceptualDialog->currentColor().spec(), //
0477                  colorOpaque.spec());
0478         QCOMPARE(tempPerceptualDialog2->currentColor().name(), //
0479                  colorOpaque.name());
0480         QCOMPARE(tempPerceptualDialog2->currentColor().alpha(), //
0481                  colorOpaque.alpha());
0482         QCOMPARE(tempPerceptualDialog2->currentColor().spec(), //
0483                  colorOpaque.spec());
0484         QCOMPARE(tempPerceptualDialog2->parentWidget(), //
0485                  tempWidget.data());
0486         QCOMPARE(tempPerceptualDialog2->parent(), //
0487                  tempWidget.data());
0488     }
0489 
0490 #ifdef Q_OS_LINUX
0491     // Linux has no native color dialog, so it is the only system guaranteed
0492     // to use QColorDialog’s own implementation not only after calling
0493     // QColorDialog::setOption(QColorDialog::DontUseNativeDialog, true);
0494     // but yet on QColorDialog’s constructor call.
0495     void testConstructorQColorQWidgetConformance_data()
0496     {
0497         helperProvideQColors();
0498     }
0499     void testConstructorQColorQWidgetConformance()
0500     {
0501         QFETCH(QColor, color);
0502 
0503         // Test the constructor ColorDialog(QWidget * parent = nullptr)
0504         m_perceptualDialog.reset( //
0505             new ColorDialog(m_srgbBuildinColorSpace, color));
0506         QScopedPointer<QWidget> tempWidget{new QWidget()};
0507         ColorDialog *tempPerceptualDialog2 = new ColorDialog( //
0508             m_srgbBuildinColorSpace,
0509             color,
0510             tempWidget.data());
0511         // Test if this coordinates is conform to QColorDialog
0512         m_qDialog.reset(new QColorDialog(color));
0513         QColorDialog *tempQDialog2 = //
0514             new QColorDialog(color, tempWidget.data());
0515         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0516         helperCompareDialog(tempPerceptualDialog2, tempQDialog2);
0517     }
0518 #endif
0519 
0520 #ifdef Q_OS_LINUX
0521     // Linux has no native color dialog, so it is the only system guaranteed
0522     // to use QColorDialog’s own implementation not only after calling
0523     // QColorDialog::setOption(QColorDialog::DontUseNativeDialog, true);
0524     // but yet on QColorDialog’s constructor call.
0525     void testConformanceWithQColorDialog_data()
0526     {
0527         QTest::addColumn<QColor>("initialColor");
0528         QTest::addColumn<QColor>("secondColor");
0529         QTest::addColumn<bool>("showAlphaChannel");
0530 
0531         QVector<QPair<QByteArray, QColor>> colorList;
0532 
0533         colorList.append( //
0534             QPair<QByteArray, QColor>(QByteArrayLiteral("redOpaque"), //
0535                                       QColor(255, 0, 0)));
0536 
0537         colorList.append( //
0538             QPair<QByteArray, QColor>(QByteArrayLiteral("greenHalf"), //
0539                                       QColor(0, 255, 0, 128)));
0540 
0541         colorList.append( //
0542             QPair<QByteArray, QColor>(QByteArrayLiteral("greenTransparent"), //
0543                                       QColor(255, 0, 255, 0)));
0544 
0545         colorList.append( //
0546             QPair<QByteArray, QColor>(QByteArrayLiteral("invalid"), //
0547                                       QColor()));
0548 
0549         for (int i = 0; i < colorList.size(); ++i) {
0550             for (int j = 0; j < colorList.size(); ++j) {
0551                 const QByteArray descriptionWithoutAlpha = //
0552                     colorList.at(i).first //
0553                     + QByteArrayLiteral("/") //
0554                     + colorList.at(j).first;
0555                 const QByteArray descriptionWithAlpha = //
0556                     descriptionWithoutAlpha //
0557                     + QByteArrayLiteral("/ShowAlphaChannel"); //
0558                 QTest::newRow(descriptionWithAlpha.constData()) //
0559                     << colorList.at(i).second //
0560                     << colorList.at(j).second //
0561                     << true;
0562                 QTest::newRow(descriptionWithoutAlpha.constData()) //
0563                     << colorList.at(i).second //
0564                     << colorList.at(j).second //
0565                     << false;
0566             }
0567         }
0568     }
0569     void testConformanceWithQColorDialog()
0570     {
0571         // Some conformance tests (without a particular systematic approach)
0572         QFETCH(QColor, initialColor);
0573         QFETCH(QColor, secondColor);
0574         QFETCH(bool, showAlphaChannel);
0575 
0576         m_perceptualDialog.reset( //
0577             new ColorDialog(m_srgbBuildinColorSpace, initialColor));
0578         m_qDialog.reset(new QColorDialog(initialColor));
0579         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0580 
0581         m_perceptualDialog->setOption( //
0582             QColorDialog::ShowAlphaChannel, //
0583             showAlphaChannel);
0584         m_qDialog->setOption( //
0585             QColorDialog::ShowAlphaChannel,
0586             showAlphaChannel);
0587 
0588         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0589 
0590         m_perceptualDialog->setCurrentColor(secondColor);
0591         m_qDialog->setCurrentColor(secondColor);
0592         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0593 
0594         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
0595         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
0596         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0597 
0598         m_perceptualDialog->setCurrentColor(secondColor);
0599         m_qDialog->setCurrentColor(secondColor);
0600         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0601 
0602         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Escape);
0603         QTest::keyClick(m_qDialog.data(), Qt::Key_Escape);
0604         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0605     }
0606 #endif
0607 
0608 #ifdef Q_OS_LINUX
0609     // Linux has no native color dialog, so it is the only system guaranteed
0610     // to use QColorDialog’s own implementation not only after calling
0611     // QColorDialog::setOption(QColorDialog::DontUseNativeDialog, true);
0612     // but yet on QColorDialog’s constructor call.
0613     void testConformanceWithQColorDialogNoButtons_data()
0614     {
0615         QTest::addColumn<bool>("showAlphaChannel");
0616         QTest::addColumn<bool>("noButtons");
0617 
0618         QTest::newRow("/ShowAlphaChannel/NoButtons") << true << true;
0619         QTest::newRow("/ShowAlphaChannel") << true << false;
0620         QTest::newRow("/NoButtons") << false << true;
0621         QTest::newRow("") << false << false;
0622     }
0623     void testConformanceWithQColorDialogNoButtons()
0624     {
0625         // Some conformance tests (without a particular systematic approach)
0626         QColor initialColor = Qt::red;
0627         QColor secondColor = Qt::green;
0628         QFETCH(bool, showAlphaChannel);
0629         QFETCH(bool, noButtons);
0630 
0631         m_perceptualDialog.reset( //
0632             new ColorDialog(m_srgbBuildinColorSpace, initialColor));
0633         m_qDialog.reset(new QColorDialog(initialColor));
0634         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0635 
0636         m_perceptualDialog->setOption( //
0637             QColorDialog::ShowAlphaChannel, //
0638             showAlphaChannel);
0639         m_qDialog->setOption( //
0640             QColorDialog::ShowAlphaChannel,
0641             showAlphaChannel);
0642 
0643         m_perceptualDialog->setOption(QColorDialog::NoButtons, noButtons);
0644         m_qDialog->setOption(QColorDialog::NoButtons, noButtons);
0645         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0646 
0647         m_perceptualDialog->setCurrentColor(secondColor);
0648         m_qDialog->setCurrentColor(secondColor);
0649         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0650 
0651         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
0652         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
0653         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0654 
0655         m_perceptualDialog->setCurrentColor(secondColor);
0656         m_qDialog->setCurrentColor(secondColor);
0657         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0658 
0659         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Escape);
0660         QTest::keyClick(m_qDialog.data(), Qt::Key_Escape);
0661         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
0662     }
0663 #endif
0664 
0665     void testColorSelectedSignal()
0666     {
0667         m_perceptualDialog.reset( //
0668             new ColorDialog(m_srgbBuildinColorSpace));
0669         m_perceptualDialog->show();
0670         m_qDialog.reset(new QColorDialog());
0671         m_qDialog->setOption(QColorDialog::DontUseNativeDialog, true);
0672         m_qDialog->show();
0673         QSignalSpy spyPerceptualDialog( //
0674             m_perceptualDialog.data(), //
0675             &ColorDialog::colorSelected);
0676         QSignalSpy spyQDialog(m_qDialog.data(), &QColorDialog::colorSelected);
0677         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
0678         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
0679         QCOMPARE(spyPerceptualDialog.count(), 1);
0680         QCOMPARE(spyPerceptualDialog.count(), spyQDialog.count());
0681         m_perceptualDialog->show();
0682         m_qDialog->show();
0683         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Escape);
0684         QTest::keyClick(m_qDialog.data(), Qt::Key_Escape);
0685         QCOMPARE(spyPerceptualDialog.count(), 1);
0686         QCOMPARE(spyPerceptualDialog.count(), spyQDialog.count());
0687         m_perceptualDialog->show();
0688         m_qDialog->show();
0689         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
0690         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
0691         QCOMPARE(spyPerceptualDialog.count(), 2);
0692         QCOMPARE(spyPerceptualDialog.count(), spyQDialog.count());
0693     }
0694 
0695     void testPropertyConformance_data()
0696     {
0697         // We provide the property names as data. To get the property names,
0698         // this function is used:
0699         // const char *QMetaProperty::name() const
0700         // Now, the type “const char *” cannot be used with QTest::addColumn<>
0701         // because it is not known to Qt’s meta object system. The
0702         // meta object system requires copy constructors for its known types.
0703         // This might get wired with pointer types that might go out of scope.
0704         // Therefore, we create a QByteArray from the data, which can be passed
0705         // without problems through the meta object system. The good thing
0706         // is that for the conversion we do not need to know anything
0707         // about the actual encoding of “const char *”.
0708         QTest::addColumn<QByteArray>("propertyName");
0709         QMetaObject referenceClass = QColorDialog::staticMetaObject;
0710         for (int i = 0; i < referenceClass.propertyCount(); ++i) {
0711             QTest::newRow(referenceClass.property(i).name()) //
0712                 << QByteArray(referenceClass.property(i).name());
0713         }
0714     }
0715 
0716     void testPropertyConformance()
0717     {
0718         QFETCH(QByteArray, propertyName);
0719         QMetaObject testClass = ColorDialog::staticMetaObject;
0720         QMetaObject referenceClass = QColorDialog::staticMetaObject;
0721         int testClassIndex = //
0722             testClass.indexOfProperty(propertyName.constData());
0723         int referenceClassIndex = //
0724             referenceClass.indexOfProperty(propertyName.constData());
0725         QMetaProperty referenceClassProperty = //
0726             referenceClass.property(referenceClassIndex);
0727         // cppcheck-suppress unreadVariable // false positive
0728         QByteArray message = //
0729             QByteArrayLiteral("Test if property \"") //
0730             + QByteArray(referenceClassProperty.name()) //
0731             + QByteArrayLiteral("\" of class \"") //
0732             + QByteArray(referenceClass.className()) //
0733             + QByteArrayLiteral("\" is also available in \"") //
0734             + QByteArray(testClass.className()) //
0735             + QByteArrayLiteral("\".");
0736         QVERIFY2(testClassIndex >= 0, message.constData());
0737         QMetaProperty testClassProperty = testClass.property(testClassIndex);
0738         if (referenceClassProperty.hasNotifySignal()) {
0739             QVERIFY2(testClassProperty.hasNotifySignal(),
0740                      "If the reference class has a notify signal, "
0741                      "the test class must have also a notify signal.");
0742         }
0743         QCOMPARE(testClassProperty.isConstant(), //
0744                  referenceClassProperty.isConstant());
0745         QCOMPARE(testClassProperty.isDesignable(), //
0746                  referenceClassProperty.isDesignable());
0747         QCOMPARE(testClassProperty.isEnumType(), //
0748                  referenceClassProperty.isEnumType());
0749         if (referenceClassProperty.isEnumType()) {
0750             QCOMPARE(testClassProperty.enumerator().enumName(), //
0751                      referenceClassProperty.enumerator().enumName());
0752             QCOMPARE(testClassProperty.enumerator().isFlag(), //
0753                      referenceClassProperty.enumerator().isFlag());
0754             QCOMPARE(testClassProperty.enumerator().isScoped(), //
0755                      referenceClassProperty.enumerator().isScoped());
0756             QCOMPARE(testClassProperty.enumerator().isValid(), //
0757                      referenceClassProperty.enumerator().isValid());
0758             QCOMPARE(testClassProperty.enumerator().keyCount(), //
0759                      referenceClassProperty.enumerator().keyCount());
0760             QCOMPARE(testClassProperty.enumerator().name(), //
0761                      referenceClassProperty.enumerator().name());
0762             QCOMPARE(testClassProperty.enumerator().scope(), //
0763                      referenceClassProperty.enumerator().scope());
0764         }
0765         QCOMPARE(testClassProperty.isFinal(), //
0766                  referenceClassProperty.isFinal());
0767         QCOMPARE(testClassProperty.isFlagType(), //
0768                  referenceClassProperty.isFlagType());
0769         QCOMPARE(testClassProperty.isReadable(), //
0770                  referenceClassProperty.isReadable());
0771         QCOMPARE(testClassProperty.isResettable(), //
0772                  referenceClassProperty.isResettable());
0773         QCOMPARE(testClassProperty.isScriptable(), //
0774                  referenceClassProperty.isScriptable());
0775         QCOMPARE(testClassProperty.isStored(), //
0776                  referenceClassProperty.isStored());
0777         QCOMPARE(testClassProperty.isUser(), //
0778                  referenceClassProperty.isUser());
0779         QCOMPARE(testClassProperty.isValid(), //
0780                  referenceClassProperty.isValid());
0781         QCOMPARE(testClassProperty.isWritable(), //
0782                  referenceClassProperty.isWritable());
0783         QCOMPARE(testClassProperty.isWritable(), //
0784                  referenceClassProperty.isWritable());
0785         QCOMPARE(testClassProperty.name(), //
0786                  referenceClassProperty.name());
0787         if (referenceClassProperty.hasNotifySignal()) {
0788             QCOMPARE(testClassProperty.notifySignal().methodSignature(), //
0789                      referenceClassProperty.notifySignal().methodSignature());
0790             QCOMPARE(testClassProperty.notifySignal().methodType(), //
0791                      referenceClassProperty.notifySignal().methodType());
0792             QCOMPARE(testClassProperty.notifySignal().name(), //
0793                      referenceClassProperty.notifySignal().name());
0794             QCOMPARE(testClassProperty.notifySignal().parameterCount(), //
0795                      referenceClassProperty.notifySignal().parameterCount());
0796             QCOMPARE(testClassProperty.notifySignal().parameterNames(), //
0797                      referenceClassProperty.notifySignal().parameterNames());
0798             QCOMPARE(testClassProperty.notifySignal().parameterTypes(), //
0799                      referenceClassProperty.notifySignal().parameterTypes());
0800             QCOMPARE(testClassProperty.notifySignal().returnType(), //
0801                      referenceClassProperty.notifySignal().returnType());
0802             QCOMPARE(testClassProperty.notifySignal().revision(), //
0803                      referenceClassProperty.notifySignal().revision());
0804             QCOMPARE(testClassProperty.notifySignal().tag(), //
0805                      referenceClassProperty.notifySignal().tag());
0806             QCOMPARE(testClassProperty.notifySignal().typeName(), //
0807                      referenceClassProperty.notifySignal().typeName());
0808         }
0809 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
0810         QCOMPARE(testClassProperty.metaType(), //
0811                  referenceClassProperty.metaType());
0812 #else
0813         QCOMPARE(testClassProperty.type(), referenceClassProperty.type());
0814 #endif
0815         QCOMPARE(testClassProperty.typeName(), //
0816                  referenceClassProperty.typeName());
0817         QCOMPARE(testClassProperty.userType(), //
0818                  referenceClassProperty.userType());
0819     }
0820 
0821     void testMethodConformance_data()
0822     {
0823         QTest::addColumn<QByteArray>("methodSignature");
0824         QTest::addColumn<int>("referenceClassIndex");
0825         QMetaObject referenceClass = QColorDialog::staticMetaObject;
0826         for (int i = 0; i < referenceClass.methodCount(); ++i) {
0827             if (referenceClass.method(i).access() != QMetaMethod::Private) {
0828                 // Exclude private methods from conformance check
0829                 QTest::newRow(referenceClass.method(i).name().data()) //
0830                     << QMetaObject::normalizedSignature( //
0831                            referenceClass.method(i).methodSignature().data()) //
0832                     << i;
0833             }
0834         }
0835     }
0836 
0837     void testMethodConformance()
0838     {
0839         // We do only check QMetaObject::method() and
0840         // not QMetaObject::constructor because QColorDialog
0841         // does not provide its constructors to the
0842         // meta-object system.
0843         QFETCH(QByteArray, methodSignature);
0844         QFETCH(int, referenceClassIndex);
0845         QMetaObject testClass = ColorDialog::staticMetaObject;
0846         QMetaObject referenceClass = QColorDialog::staticMetaObject;
0847         int testClassIndex = testClass.indexOfMethod(methodSignature.data());
0848         QMetaMethod referenceClassMethod = //
0849             referenceClass.method(referenceClassIndex);
0850         // cppcheck-suppress unreadVariable // false positive
0851         QByteArray message = //
0852             QByteArrayLiteral("Test if method \"") //
0853             + QByteArray(referenceClassMethod.methodSignature()) //
0854             + QByteArrayLiteral("\" of class \"") //
0855             + QByteArray(referenceClass.className()) //
0856             + QByteArrayLiteral("\" is also available in \"") //
0857             + QByteArray(testClass.className()) //
0858             + QByteArrayLiteral("\".");
0859         QVERIFY2(testClassIndex >= 0, message.constData());
0860         QMetaMethod testClassMethod = testClass.method(testClassIndex);
0861         QCOMPARE(testClassMethod.access(), //
0862                  referenceClassMethod.access());
0863         QCOMPARE(testClassMethod.isValid(), //
0864                  referenceClassMethod.isValid());
0865         QCOMPARE(testClassMethod.methodSignature(), //
0866                  referenceClassMethod.methodSignature());
0867         QCOMPARE(testClassMethod.methodType(), //
0868                  referenceClassMethod.methodType());
0869         QCOMPARE(testClassMethod.name(), //
0870                  referenceClassMethod.name());
0871         QCOMPARE(testClassMethod.parameterCount(), //
0872                  referenceClassMethod.parameterCount());
0873         QCOMPARE(testClassMethod.parameterNames(), //
0874                  referenceClassMethod.parameterNames());
0875         QCOMPARE(testClassMethod.parameterTypes(), //
0876                  referenceClassMethod.parameterTypes());
0877         QCOMPARE(testClassMethod.returnType(), //
0878                  referenceClassMethod.returnType());
0879         QCOMPARE(testClassMethod.revision(), //
0880                  referenceClassMethod.revision());
0881         QCOMPARE(testClassMethod.tag(), //
0882                  referenceClassMethod.tag());
0883         QCOMPARE(testClassMethod.typeName(), //
0884                  referenceClassMethod.typeName());
0885     }
0886 
0887     void testRttiConformance()
0888     {
0889         QMetaObject testClass = ColorDialog::staticMetaObject;
0890         QMetaObject referenceClass = QColorDialog::staticMetaObject;
0891         QVERIFY2(testClass.inherits(referenceClass.superClass()),
0892                  "Test that ColorDialog inherits "
0893                  "from QColorDialog’s superclass.");
0894     }
0895 
0896     void testCurrentColorChangedSignal()
0897     {
0898         m_perceptualDialog.reset( //
0899             new ColorDialog(m_srgbBuildinColorSpace));
0900         m_qDialog.reset(new QColorDialog());
0901         m_perceptualDialog->show();
0902         m_qDialog->show();
0903         QSignalSpy spyPerceptualDialog( //
0904             m_perceptualDialog.data(), //
0905             &ColorDialog::currentColorChanged);
0906         QSignalSpy spyQDialog(m_qDialog.data(), //
0907                               &QColorDialog::currentColorChanged);
0908 
0909         // Test that a simple “return key” click by the user
0910         // does not call this signal
0911         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
0912         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
0913         QCOMPARE(spyPerceptualDialog.count(), 0);
0914         QCOMPARE(spyPerceptualDialog.count(), spyQDialog.count());
0915 
0916         // A different color should call the signal
0917         m_perceptualDialog->setCurrentColor(QColor(1, 2, 3));
0918         m_qDialog->setCurrentColor(QColor(1, 2, 3));
0919         QCOMPARE(spyPerceptualDialog.count(), 1);
0920         QCOMPARE(spyPerceptualDialog.count(), spyQDialog.count());
0921 
0922         // The same color again should not call again the signal
0923         m_perceptualDialog->setCurrentColor(QColor(1, 2, 3));
0924         m_qDialog->setCurrentColor(QColor(1, 2, 3));
0925         QCOMPARE(spyPerceptualDialog.count(), 1);
0926         QCOMPARE(spyPerceptualDialog.count(), spyQDialog.count());
0927 
0928         // The same RGB values, but defined in another color model, should not
0929         // emit a signal either.
0930         m_perceptualDialog->setCurrentColor(QColor(1, 2, 3).toHsl());
0931         m_qDialog->setCurrentColor(QColor(1, 2, 3).toHsl());
0932         QCOMPARE(spyPerceptualDialog.count(), 1);
0933         QCOMPARE(spyPerceptualDialog.count(), spyQDialog.count());
0934 
0935         // Changing QColorDialog::ShowAlphaChannel should
0936         // not emit a signal either
0937         m_perceptualDialog->setOption( //
0938             QColorDialog::ShowAlphaChannel, //
0939             false);
0940         m_qDialog->setOption( //
0941             QColorDialog::ShowAlphaChannel, //
0942             false);
0943         QCOMPARE(spyPerceptualDialog.count(), 1);
0944         QCOMPARE(spyPerceptualDialog.count(), spyQDialog.count());
0945     }
0946 
0947     void testCurrentColorProperty_data()
0948     {
0949         helperProvideQColors();
0950     }
0951 
0952     void testCurrentColorProperty()
0953     {
0954         QFETCH(QColor, color);
0955         QColor correctedColor;
0956         if (color.isValid()) {
0957             correctedColor = color.toRgb();
0958         } else {
0959             correctedColor = Qt::black;
0960         }
0961         QColor opaqueColor = correctedColor;
0962         opaqueColor.setAlpha(255);
0963 
0964         m_perceptualDialog.reset( //
0965             new ColorDialog(m_srgbBuildinColorSpace));
0966         m_qDialog.reset(new QColorDialog);
0967         m_qDialog->setOption(QColorDialog::DontUseNativeDialog, true);
0968         m_perceptualDialog->setOption( //
0969             QColorDialog::ShowAlphaChannel, //
0970             true);
0971         m_qDialog->setOption( //
0972             QColorDialog::ShowAlphaChannel, //
0973             true);
0974         m_perceptualDialog->setCurrentColor(color);
0975         m_qDialog->setCurrentColor(color);
0976         // Test conformance (but only integer precision)
0977         QCOMPARE(m_perceptualDialog->currentColor().rgb(), //
0978                  m_qDialog->currentColor().rgb());
0979         if (color.isValid()) {
0980             // Testing alpha value conformance only for valid QColor inputs,
0981             // because QColorDialog has here some surprising behaviour that
0982             // we won’t imitate.
0983             QCOMPARE(m_perceptualDialog->currentColor().alpha(), //
0984                      m_qDialog->currentColor().alpha());
0985         }
0986         QCOMPARE(static_cast<int>(m_perceptualDialog->currentColor().spec()), //
0987                  static_cast<int>(m_qDialog->currentColor().spec()));
0988         // Test post condition (but only integer precision)
0989         QCOMPARE(m_perceptualDialog->currentColor().rgb(), //
0990                  correctedColor.rgb());
0991         QCOMPARE(m_perceptualDialog->currentColor().alpha(), //
0992                  correctedColor.alpha());
0993         QCOMPARE(static_cast<int>(m_perceptualDialog->currentColor().spec()), //
0994                  static_cast<int>(correctedColor.spec()));
0995 
0996         // Test that changing QColorDialog::ShowAlphaChannel
0997         // alone does not change the currentColor property
0998         m_perceptualDialog->setOption( //
0999             QColorDialog::ShowAlphaChannel, //
1000             false);
1001         m_qDialog->setOption( //
1002             QColorDialog::ShowAlphaChannel, //
1003             false);
1004         // Test conformance (but only integer precision)
1005         QCOMPARE(m_perceptualDialog->currentColor().rgb(), //
1006                  m_qDialog->currentColor().rgb());
1007         if (color.isValid()) {
1008             // Testing alpha value conformance only for valid QColor inputs,
1009             // because QColorDialog has here some surprising behaviour that
1010             // we won’t imitate.
1011             QCOMPARE(m_perceptualDialog->currentColor().alpha(), //
1012                      m_qDialog->currentColor().alpha());
1013         }
1014         QCOMPARE(static_cast<int>(m_perceptualDialog->currentColor().spec()), //
1015                  static_cast<int>(m_qDialog->currentColor().spec()));
1016         // Test post condition (but only integer precision)
1017         QCOMPARE(m_perceptualDialog->currentColor().rgb(), //
1018                  correctedColor.rgb());
1019         QCOMPARE(m_perceptualDialog->currentColor().alpha(), //
1020                  correctedColor.alpha());
1021         QCOMPARE(static_cast<int>(m_perceptualDialog->currentColor().spec()), //
1022                  static_cast<int>(correctedColor.spec()));
1023 
1024         m_perceptualDialog->setOption(QColorDialog::ShowAlphaChannel, false);
1025         m_qDialog->setOption( //
1026             QColorDialog::ShowAlphaChannel, //
1027             false);
1028         m_perceptualDialog->setCurrentColor(color);
1029         m_qDialog->setCurrentColor(color);
1030         // Test conformance (but only integer precision)
1031         QCOMPARE(m_perceptualDialog->currentColor().rgb(), //
1032                  m_qDialog->currentColor().rgb());
1033         QCOMPARE(m_perceptualDialog->currentColor().alpha(), //
1034                  m_qDialog->currentColor().alpha());
1035         QCOMPARE(static_cast<int>(m_perceptualDialog->currentColor().spec()), //
1036                  static_cast<int>(m_qDialog->currentColor().spec()));
1037         // Test post condition (but only integer precision)
1038         QCOMPARE(m_perceptualDialog->currentColor().rgb(), opaqueColor.rgb());
1039         QCOMPARE(m_perceptualDialog->currentColor().alpha(), //
1040                  opaqueColor.alpha());
1041         QCOMPARE(static_cast<int>(m_perceptualDialog->currentColor().spec()), //
1042                  static_cast<int>(opaqueColor.spec()));
1043 
1044         // Test that changing QColorDialog::ShowAlphaChannel
1045         // alone does not change the currentColor property
1046         m_perceptualDialog->setOption( //
1047             QColorDialog::ShowAlphaChannel, //
1048             true);
1049         m_qDialog->setOption( //
1050             QColorDialog::ShowAlphaChannel, //
1051             true);
1052         // Test conformance (but only integer precision)
1053         QCOMPARE(m_perceptualDialog->currentColor().rgb(), //
1054                  m_qDialog->currentColor().rgb());
1055         QCOMPARE(m_perceptualDialog->currentColor().alpha(), //
1056                  m_qDialog->currentColor().alpha());
1057         QCOMPARE(static_cast<int>(m_perceptualDialog->currentColor().spec()), //
1058                  static_cast<int>(m_qDialog->currentColor().spec()));
1059         // Test post condition (but only integer precision)
1060         QCOMPARE(m_perceptualDialog->currentColor().rgb(), opaqueColor.rgb());
1061         QCOMPARE(m_perceptualDialog->currentColor().alpha(), //
1062                  opaqueColor.alpha());
1063         QCOMPARE(static_cast<int>(m_perceptualDialog->currentColor().spec()), //
1064                  static_cast<int>(opaqueColor.spec()));
1065     }
1066 
1067 #ifndef MSVC_DLL
1068     void testSetCurrentColor()
1069     {
1070         m_perceptualDialog.reset( //
1071             new ColorDialog(m_srgbBuildinColorSpace));
1072         m_perceptualDialog->show();
1073         constexpr auto testColor = Qt::yellow;
1074         m_perceptualDialog->setCurrentColor(testColor);
1075 
1076         // Get internal LCH value
1077         const auto tmp = m_perceptualDialog->d_pointer->m_currentOpaqueColorAbs;
1078         const LchDouble color = //
1079             tmp.value(ColorModel::CielchD50).reinterpretAsLchToLchDouble();
1080 
1081         // The very same LCH value has to be found in all widgets using it.
1082         // (This is not trivial, because even coming from RGB, because of
1083         // rounding errors, you can get out-of-gamut LCH values when the
1084         // original RGB value was near to the border. And the child
1085         // widgets may change the LCH value that is given to them
1086         // to fit it into the gamut – each widget with a different
1087         // algorithm.)
1088         QVERIFY( //
1089             color.hasSameCoordinates( //
1090                 m_perceptualDialog //
1091                     ->d_pointer //
1092                     ->m_wheelColorPicker //
1093                     ->currentColor()));
1094         QVERIFY( //
1095             color.hasSameCoordinates( //
1096                 m_perceptualDialog //
1097                     ->d_pointer //
1098                     ->m_chromaHueDiagram //
1099                     ->currentColor()));
1100         // We do not also control this here for
1101         // m_perceptualDialog->d_pointer->m_ciehlcD50SpinBox because this
1102         // widget rounds the given value to the current decimal precision
1103         // it’s using. Therefore, it’s pointless to control here
1104         // for rounding errors.
1105 
1106         const auto sliderColor = //
1107             m_perceptualDialog->d_pointer->m_alphaGradientSlider->secondColor();
1108         QCOMPARE(sliderColor.l, color.l);
1109         QCOMPARE(sliderColor.c, color.c);
1110         QCOMPARE(sliderColor.h, color.h);
1111     }
1112 #endif
1113 
1114     void testOpen()
1115     {
1116         // Test our reference (QColorDialog)
1117         m_color = Qt::black;
1118         m_qDialog.reset(new QColorDialog);
1119         m_qDialog->setOption(QColorDialog::DontUseNativeDialog, true);
1120         m_qDialog->setCurrentColor(Qt::white);
1121         m_qDialog->open(this, SLOT(helperReceiveSignals(QColor)));
1122         m_qDialog->setCurrentColor(Qt::red);
1123         // Changing the current color does not emit the signal
1124         QCOMPARE(m_color, Qt::black);
1125         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
1126         // Return key really emits a signal
1127         QCOMPARE(m_color, Qt::red);
1128         m_qDialog->show();
1129         m_qDialog->setCurrentColor(Qt::green);
1130         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
1131         // The signal is really disconnected after the dialog has been closed.
1132         QCOMPARE(m_color, Qt::red);
1133 
1134         // Now test if ColorDialog does the same
1135         // thing as our reference
1136         m_color = Qt::black;
1137         m_perceptualDialog.reset( //
1138             new ColorDialog(m_srgbBuildinColorSpace));
1139         m_perceptualDialog->setCurrentColor(Qt::white);
1140         m_perceptualDialog->open(this, SLOT(helperReceiveSignals(QColor)));
1141         m_perceptualDialog->setCurrentColor(Qt::red);
1142         // Changing the current color does not emit the signal
1143         QCOMPARE(m_color, Qt::black);
1144         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
1145         // Return key really emits a signal
1146         QCOMPARE(m_color, Qt::red);
1147         m_perceptualDialog->show();
1148         m_perceptualDialog->setCurrentColor(Qt::green);
1149         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
1150         // The signal is really disconnected after the dialog has been closed.
1151         QCOMPARE(m_color, Qt::red);
1152     }
1153 
1154     void testDefaultOptions()
1155     {
1156         m_perceptualDialog.reset( //
1157             new ColorDialog(m_srgbBuildinColorSpace));
1158         m_qDialog.reset(new QColorDialog);
1159         QCOMPARE( //
1160             m_perceptualDialog->testOption( //
1161                 QColorDialog::DontUseNativeDialog), //
1162             true);
1163         QCOMPARE( //
1164             m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1165             false);
1166         QCOMPARE( //
1167             m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1168             m_qDialog->testOption(QColorDialog::NoButtons));
1169         QCOMPARE( //
1170             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1171             false);
1172         QCOMPARE( //
1173             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1174             m_qDialog->testOption(QColorDialog::ShowAlphaChannel));
1175         QCOMPARE( //
1176             m_perceptualDialog->options().testFlag( //
1177                 QColorDialog::DontUseNativeDialog), //
1178             true);
1179         QCOMPARE( //
1180             m_perceptualDialog->options().testFlag(QColorDialog::NoButtons), //
1181             false);
1182         QCOMPARE( //
1183             m_perceptualDialog->options().testFlag(QColorDialog::NoButtons), //
1184             m_qDialog->options().testFlag(QColorDialog::NoButtons));
1185         QCOMPARE( //
1186             m_perceptualDialog->options().testFlag( //
1187                 QColorDialog::ShowAlphaChannel), //
1188             false);
1189         QCOMPARE( //
1190             m_perceptualDialog->options().testFlag( //
1191                 QColorDialog::ShowAlphaChannel), //
1192             m_qDialog->options().testFlag(QColorDialog::ShowAlphaChannel));
1193     }
1194 
1195     void testOptionDontUseNativeDialogAlwaysTrue()
1196     {
1197         m_perceptualDialog.reset( //
1198             new ColorDialog(m_srgbBuildinColorSpace));
1199         m_perceptualDialog->setOption(QColorDialog::DontUseNativeDialog);
1200         QCOMPARE( //
1201             m_perceptualDialog->testOption( //
1202                 QColorDialog::DontUseNativeDialog), //
1203             true);
1204         QCOMPARE( //
1205             m_perceptualDialog->options().testFlag( //
1206                 QColorDialog::DontUseNativeDialog), //
1207             true);
1208         m_perceptualDialog->setOptions(QColorDialog::DontUseNativeDialog);
1209         QCOMPARE( //
1210             m_perceptualDialog->testOption( //
1211                 QColorDialog::DontUseNativeDialog), //
1212             true);
1213         QCOMPARE( //
1214             m_perceptualDialog->options().testFlag( //
1215                 QColorDialog::DontUseNativeDialog),
1216             true);
1217         m_perceptualDialog->setOptions( //
1218             QColorDialog::DontUseNativeDialog | QColorDialog::NoButtons);
1219         QCOMPARE( //
1220             m_perceptualDialog->testOption( //
1221                 QColorDialog::DontUseNativeDialog), //
1222             true);
1223         QCOMPARE( //
1224             m_perceptualDialog->options().testFlag( //
1225                 QColorDialog::DontUseNativeDialog), //
1226             true);
1227         m_perceptualDialog->setOptions( //
1228             QColorDialog::DontUseNativeDialog | QColorDialog::ShowAlphaChannel);
1229         QCOMPARE( //
1230             m_perceptualDialog->testOption( //
1231                 QColorDialog::DontUseNativeDialog), //
1232             true);
1233         QCOMPARE( //
1234             m_perceptualDialog->options().testFlag( //
1235                 QColorDialog::DontUseNativeDialog), //
1236             true);
1237         m_perceptualDialog->setOptions( //
1238             QColorDialog::DontUseNativeDialog //
1239             | QColorDialog::ShowAlphaChannel //
1240             | QColorDialog::NoButtons);
1241         QCOMPARE( //
1242             m_perceptualDialog->testOption( //
1243                 QColorDialog::DontUseNativeDialog), //
1244             true);
1245         QCOMPARE( //
1246             m_perceptualDialog->options().testFlag( //
1247                 QColorDialog::DontUseNativeDialog), //
1248             true);
1249     }
1250 
1251 #ifdef Q_OS_LINUX
1252     // Linux has no native color dialog, so it is the only system guaranteed
1253     // to use QColorDialog’s own implementation not only after calling
1254     // QColorDialog::setOption(QColorDialog::DontUseNativeDialog, true);
1255     // but yet on QColorDialog’s constructor call.
1256     void testOptionShowAlpha()
1257     {
1258         m_perceptualDialog.reset( //
1259             new ColorDialog(m_srgbBuildinColorSpace, QColor(Qt::white)));
1260         m_qDialog.reset(new QColorDialog);
1261         m_perceptualDialog->setOption( //
1262             QColorDialog::ShowAlphaChannel);
1263         QVERIFY2( //
1264             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1265             "ShowAlphaChannel successfully set.");
1266         m_qDialog->setOption(QColorDialog::ShowAlphaChannel);
1267         m_perceptualDialog->show();
1268         m_qDialog->show();
1269         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
1270         QColor tempColor = QColor(1, 101, 201, 155);
1271         m_perceptualDialog->setCurrentColor(tempColor);
1272         m_qDialog->setCurrentColor(tempColor);
1273         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
1274         m_perceptualDialog->setOption( //
1275             QColorDialog::ShowAlphaChannel, //
1276             false);
1277         QVERIFY2( //
1278             !m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1279             "ShowAlphaChannel successfully set.");
1280         m_qDialog->setOption(QColorDialog::ShowAlphaChannel, false);
1281         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
1282         tempColor = QColor(5, 105, 205, 133);
1283         m_perceptualDialog->setCurrentColor(tempColor);
1284         m_qDialog->setCurrentColor(tempColor);
1285         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
1286     }
1287 #endif
1288 
1289 #ifdef Q_OS_LINUX
1290     // Linux has no native color dialog, so it is the only system guaranteed
1291     // to use QColorDialog’s own implementation not only after calling
1292     // QColorDialog::setOption(QColorDialog::DontUseNativeDialog, true);
1293     // but yet on QColorDialog’s constructor call.
1294     void testOptionNoButtons()
1295     {
1296         m_perceptualDialog.reset( //
1297             new ColorDialog( //
1298                 m_srgbBuildinColorSpace, //
1299                 QColor(Qt::white) //
1300                 ) //
1301         );
1302         m_qDialog.reset(new QColorDialog);
1303         m_perceptualDialog->setOption( //
1304             QColorDialog::NoButtons);
1305         QVERIFY2( //
1306             m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1307             "NoButtons successfully set to true.");
1308         m_qDialog->setOption(QColorDialog::NoButtons);
1309         m_perceptualDialog->show();
1310         m_qDialog->show();
1311         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
1312         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
1313         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
1314         QCOMPARE(m_perceptualDialog->isVisible(), m_qDialog->isVisible());
1315         QVERIFY2(m_perceptualDialog->isVisible(), //
1316                  "Should still visible after Return key pressed.");
1317         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
1318         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Escape);
1319         QTest::keyClick(m_qDialog.data(), Qt::Key_Escape);
1320         QCOMPARE(m_perceptualDialog->isVisible(), m_qDialog->isVisible());
1321         QVERIFY2(!m_perceptualDialog->isVisible(), //
1322                  "Should no longer be visible after Escape key pressed.");
1323         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
1324 
1325         m_perceptualDialog->setOption(QColorDialog::NoButtons, false);
1326         QVERIFY2(!m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1327                  "NoButtons successfully set to false.");
1328         m_qDialog->setOption(QColorDialog::NoButtons, false);
1329         m_perceptualDialog->show();
1330         m_qDialog->show();
1331         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
1332         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
1333         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
1334         QCOMPARE(m_perceptualDialog->isVisible(), m_qDialog->isVisible());
1335         QVERIFY2(!m_perceptualDialog->isVisible(), //
1336                  "Should no longer be visible after Return key pressed.");
1337         helperCompareDialog(m_perceptualDialog.data(), m_qDialog.data());
1338     }
1339 #endif
1340 
1341     void testSetOptionAndTestOptionInteraction()
1342     {
1343         m_perceptualDialog.reset( //
1344             new ColorDialog(m_srgbBuildinColorSpace));
1345         // Test if the option changes as expected
1346         m_perceptualDialog->setOption(QColorDialog::ShowAlphaChannel, //
1347                                       true);
1348         QCOMPARE( //
1349             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1350             true);
1351         m_perceptualDialog->setOption(QColorDialog::ShowAlphaChannel, //
1352                                       false);
1353         QCOMPARE( //
1354             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1355             false);
1356         m_perceptualDialog->setOption(QColorDialog::ShowAlphaChannel, //
1357                                       true);
1358         QCOMPARE( //
1359             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1360             true);
1361         m_perceptualDialog->setOption(QColorDialog::ShowAlphaChannel, //
1362                                       false);
1363         QCOMPARE( //
1364             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1365             false);
1366         m_perceptualDialog.reset(nullptr);
1367 
1368         m_perceptualDialog.reset( //
1369             new ColorDialog(m_srgbBuildinColorSpace));
1370         // Test if the option changes as expected
1371         m_perceptualDialog->setOption(QColorDialog::ShowAlphaChannel, //
1372                                       false);
1373         QCOMPARE( //
1374             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1375             false);
1376         m_perceptualDialog->setOption(QColorDialog::ShowAlphaChannel, //
1377                                       true);
1378         QCOMPARE( //
1379             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1380             true);
1381         m_perceptualDialog->setOption(QColorDialog::ShowAlphaChannel, //
1382                                       false);
1383         QCOMPARE( //
1384             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1385             false);
1386         m_perceptualDialog->setOption(QColorDialog::ShowAlphaChannel, //
1387                                       true);
1388         QCOMPARE( //
1389             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1390             true);
1391         m_perceptualDialog.reset(nullptr);
1392 
1393         m_perceptualDialog.reset( //
1394             new ColorDialog(m_srgbBuildinColorSpace));
1395         // Test if the option changes as expected
1396         m_perceptualDialog->setOption( //
1397             QColorDialog::NoButtons, //
1398             true);
1399         QCOMPARE( //
1400             m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1401             true);
1402         m_perceptualDialog->setOption( //
1403             QColorDialog::NoButtons, //
1404             false);
1405         QCOMPARE(m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1406                  false);
1407         m_perceptualDialog->setOption( //
1408             QColorDialog::NoButtons, //
1409             true);
1410         QCOMPARE(m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1411                  true);
1412         m_perceptualDialog->setOption( //
1413             QColorDialog::NoButtons, //
1414             false);
1415         QCOMPARE(m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1416                  false);
1417         m_perceptualDialog.reset(nullptr);
1418 
1419         m_perceptualDialog.reset( //
1420             new ColorDialog(m_srgbBuildinColorSpace));
1421         // Test if the option changes as expected
1422         m_perceptualDialog->setOption( //
1423             QColorDialog::NoButtons, //
1424             false);
1425         QCOMPARE( //
1426             m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1427             false);
1428         m_perceptualDialog->setOption(QColorDialog::NoButtons, true);
1429         QCOMPARE( //
1430             m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1431             true);
1432         m_perceptualDialog->setOption( //
1433             QColorDialog::NoButtons, //
1434             false);
1435         QCOMPARE( //
1436             m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1437             false);
1438         m_perceptualDialog->setOption( //
1439             QColorDialog::NoButtons, //
1440             true);
1441         QCOMPARE( //
1442             m_perceptualDialog->testOption(QColorDialog::NoButtons), //
1443             true);
1444         m_perceptualDialog.reset(nullptr);
1445 
1446         m_perceptualDialog.reset( //
1447             new ColorDialog(m_srgbBuildinColorSpace));
1448         // define an option
1449         m_perceptualDialog->setOption( //
1450             QColorDialog::ShowAlphaChannel, //
1451             true);
1452         // change some other option
1453         m_perceptualDialog->setOption( //
1454             QColorDialog::NoButtons, //
1455             true);
1456         // test if first option is still unchanged
1457         QCOMPARE( //
1458             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1459             true);
1460         m_perceptualDialog.reset(nullptr);
1461 
1462         m_perceptualDialog.reset( //
1463             new ColorDialog(m_srgbBuildinColorSpace));
1464         // define an option
1465         m_perceptualDialog->setOption( //
1466             QColorDialog::ShowAlphaChannel, //
1467             false);
1468         // change some other option
1469         m_perceptualDialog->setOption( //
1470             QColorDialog::NoButtons, //
1471             true);
1472         // test if first option is still unchanged
1473         QCOMPARE( //
1474             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1475             false);
1476         m_perceptualDialog.reset(nullptr);
1477 
1478         m_perceptualDialog.reset( //
1479             new ColorDialog(m_srgbBuildinColorSpace));
1480         // define an option
1481         m_perceptualDialog->setOption( //
1482             QColorDialog::ShowAlphaChannel, //
1483             true);
1484         // change some other option
1485         m_perceptualDialog->setOption( //
1486             QColorDialog::NoButtons, //
1487             false);
1488         // test if first option is still unchanged
1489         QCOMPARE( //
1490             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1491             true);
1492         m_perceptualDialog.reset(nullptr);
1493 
1494         m_perceptualDialog.reset( //
1495             new ColorDialog(m_srgbBuildinColorSpace));
1496         // define an option
1497         m_perceptualDialog->setOption( //
1498             QColorDialog::ShowAlphaChannel, //
1499             false);
1500         // change some other option
1501         m_perceptualDialog->setOption( //
1502             QColorDialog::NoButtons, //
1503             false);
1504         // test if first option is still unchanged
1505         QCOMPARE( //
1506             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1507             false);
1508         m_perceptualDialog.reset(nullptr);
1509     }
1510 
1511     void testRgbInput()
1512     {
1513         m_perceptualDialog.reset( //
1514             new ColorDialog(m_srgbBuildinColorSpace));
1515         m_perceptualDialog->setOption( //
1516             QColorDialog::ShowAlphaChannel, //
1517             true);
1518     }
1519 
1520     void testAlphaSpinbox()
1521     {
1522         m_perceptualDialog.reset( //
1523             new ColorDialog(m_srgbBuildinColorSpace));
1524         m_perceptualDialog->setOption( //
1525             QColorDialog::ShowAlphaChannel, //
1526             true);
1527         m_perceptualDialog->d_pointer->m_alphaGradientSlider->setValue(0.504);
1528         QCOMPARE( //
1529             m_perceptualDialog->d_pointer->m_alphaGradientSlider->value(), //
1530             0.504);
1531         QCOMPARE(m_perceptualDialog->d_pointer->m_alphaSpinBox->value(), 50);
1532         QTest::keyClick(m_perceptualDialog->d_pointer->m_alphaSpinBox, //
1533                         Qt::Key_Up);
1534         QCOMPARE( //
1535             m_perceptualDialog->d_pointer->m_alphaGradientSlider->value(), //
1536             0.51);
1537         QCOMPARE(m_perceptualDialog->d_pointer->m_alphaSpinBox->value(), 51);
1538     }
1539 
1540 #ifdef Q_OS_LINUX
1541     // Linux has no native color dialog, so it is the only system guaranteed
1542     // to use QColorDialog’s own implementation not only after calling
1543     // QColorDialog::setOption(QColorDialog::DontUseNativeDialog, true);
1544     // but yet on QColorDialog’s constructor call.
1545     void testSelectedColorAndSetVisible()
1546     {
1547         m_perceptualDialog.reset( //
1548             new ColorDialog(m_srgbBuildinColorSpace));
1549         m_qDialog.reset(new QColorDialog);
1550         QCOMPARE(m_perceptualDialog->selectedColor(), //
1551                  m_qDialog->selectedColor());
1552         QCOMPARE(m_perceptualDialog->selectedColor(), QColor());
1553         m_perceptualDialog->setCurrentColor(QColor(Qt::blue));
1554         m_qDialog->setCurrentColor(QColor(Qt::blue));
1555         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
1556         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
1557         // Still no valid selectedColor() because the dialog still wasn't shown
1558         QCOMPARE(m_perceptualDialog->selectedColor(), //
1559                  m_qDialog->selectedColor());
1560         QCOMPARE(m_perceptualDialog->selectedColor(), QColor());
1561         m_perceptualDialog->show();
1562         m_qDialog->show();
1563         QCOMPARE(m_perceptualDialog->selectedColor(), //
1564                  m_qDialog->selectedColor());
1565         QCOMPARE(m_perceptualDialog->selectedColor(), QColor());
1566         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
1567         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
1568         QCOMPARE(m_perceptualDialog->selectedColor(), //
1569                  m_qDialog->selectedColor());
1570         QCOMPARE(m_perceptualDialog->selectedColor(), QColor(Qt::blue));
1571         m_perceptualDialog->show();
1572         m_qDialog->show();
1573         QCOMPARE(m_perceptualDialog->selectedColor(), //
1574                  m_qDialog->selectedColor());
1575         QCOMPARE(m_perceptualDialog->selectedColor(), QColor());
1576         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Escape);
1577         QTest::keyClick(m_qDialog.data(), Qt::Key_Escape);
1578         QCOMPARE(m_perceptualDialog->selectedColor(), //
1579                  m_qDialog->selectedColor());
1580         QCOMPARE(m_perceptualDialog->selectedColor(), QColor());
1581         m_perceptualDialog->setVisible(true);
1582         m_qDialog->setVisible(true);
1583         QCOMPARE(m_perceptualDialog->selectedColor(), //
1584                  m_qDialog->selectedColor());
1585         QCOMPARE(m_perceptualDialog->selectedColor(), QColor());
1586         QTest::keyClick(m_perceptualDialog.data(), Qt::Key_Return);
1587         QTest::keyClick(m_qDialog.data(), Qt::Key_Return);
1588         QCOMPARE(m_perceptualDialog->selectedColor(), //
1589                  m_qDialog->selectedColor());
1590         QCOMPARE(m_perceptualDialog->selectedColor(), QColor(Qt::blue));
1591         m_perceptualDialog->show();
1592         m_qDialog->show();
1593         QCOMPARE(m_perceptualDialog->selectedColor(), //
1594                  m_qDialog->selectedColor());
1595         QCOMPARE(m_perceptualDialog->selectedColor(), QColor());
1596         m_perceptualDialog->hide();
1597         m_qDialog->hide();
1598         QCOMPARE(m_perceptualDialog->selectedColor(), //
1599                  m_qDialog->selectedColor());
1600         QCOMPARE(m_perceptualDialog->selectedColor(), QColor());
1601     }
1602 #endif
1603 
1604     void testAliases()
1605     {
1606         m_perceptualDialog.reset( //
1607             new ColorDialog(m_srgbBuildinColorSpace));
1608         m_qDialog.reset(new QColorDialog);
1609 
1610         // Test setting QColorDialog syntax
1611         m_perceptualDialog->setOption(QColorDialog::ShowAlphaChannel);
1612         QCOMPARE( //
1613             m_perceptualDialog->testOption(QColorDialog::ShowAlphaChannel), //
1614             true);
1615         QCOMPARE( //
1616             m_perceptualDialog->testOption //
1617             (ColorDialog::ColorDialogOption::ShowAlphaChannel), //
1618             true);
1619         m_qDialog->setOption( //
1620             QColorDialog::ShowAlphaChannel);
1621         QCOMPARE(m_qDialog->testOption(QColorDialog::ShowAlphaChannel), //
1622                  true);
1623         QCOMPARE( //
1624             m_qDialog->testOption( //
1625                 ColorDialog::ColorDialogOption::ShowAlphaChannel), //
1626             true);
1627 
1628         // Test setting our alias syntax
1629         m_perceptualDialog->setOption( //
1630             ColorDialog::ColorDialogOption::NoButtons);
1631         QCOMPARE( //
1632             m_perceptualDialog->testOption(QColorDialog::NoButtons),
1633             true);
1634         QCOMPARE( //
1635             m_perceptualDialog->testOption( //
1636                 ColorDialog::ColorDialogOption::NoButtons), //
1637             true);
1638         m_qDialog->setOption( //
1639             ColorDialog::ColorDialogOption::NoButtons);
1640         QCOMPARE(m_qDialog->testOption(QColorDialog::NoButtons), //
1641                  true);
1642         QCOMPARE( //
1643             m_qDialog->testOption(ColorDialog::ColorDialogOption::NoButtons), //
1644             true);
1645 
1646         // Test if ColorDialogOptions is compatible (at least for == operator)
1647         // Configure conformance with our dialog:
1648         m_qDialog->setOption(QColorDialog::DontUseNativeDialog);
1649         QCOMPARE(m_perceptualDialog->options(), m_qDialog->options());
1650     }
1651 
1652 #ifndef MSVC_DLL
1653     void testReadLightnessValues()
1654     {
1655         QScopedPointer<ColorDialog> myDialog( //
1656             new ColorDialog(m_srgbBuildinColorSpace));
1657         myDialog->d_pointer->m_lchLightnessSelector->setValue(0.6);
1658         myDialog->d_pointer->readLightnessValue();
1659         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::CielchD50).first, 60);
1660     }
1661 #endif
1662 
1663     void testGamutIconCiehlcD50()
1664     {
1665         QScopedPointer<ColorDialog> myDialog( //
1666             new ColorDialog(m_srgbBuildinColorSpace));
1667 
1668         // On startup, the current color should be in-gamut, so no gamut action
1669         // should be visible.
1670         QCOMPARE( //
1671             myDialog->d_pointer->m_ciehlcD50SpinBoxGamutAction->isVisible(), //
1672             false);
1673         QCOMPARE( //
1674             myDialog->d_pointer->m_oklchSpinBoxGamutAction->isVisible(), //
1675             false);
1676 
1677         constexpr int iterations = 15;
1678 
1679         auto &myCiehlcD50SpinBox = myDialog->d_pointer->m_ciehlcD50SpinBox;
1680         myCiehlcD50SpinBox->setFocus();
1681         QTest::keyClick(myCiehlcD50SpinBox, Qt::Key_Tab);
1682         QTest::keyClick(myCiehlcD50SpinBox, Qt::Key_Tab);
1683         // Now, the focus should be on the chroma value.
1684         for (int i = 0; i < iterations; ++i) {
1685             QTest::keyClick(myCiehlcD50SpinBox, Qt::Key_PageUp);
1686         }
1687         QCOMPARE( //
1688             myDialog->d_pointer->m_ciehlcD50SpinBoxGamutAction->isVisible(), //
1689             true);
1690         for (int i = 0; i < iterations; ++i) {
1691             QTest::keyClick(myCiehlcD50SpinBox, Qt::Key_PageDown);
1692         }
1693         QCOMPARE( //
1694             myDialog->d_pointer->m_ciehlcD50SpinBoxGamutAction->isVisible(), //
1695             false);
1696     }
1697 
1698     void testGamutIconOklch()
1699     {
1700         QScopedPointer<ColorDialog> myDialog( //
1701             new ColorDialog(m_srgbBuildinColorSpace));
1702 
1703         // On startup, the current color should be in-gamut, so no gamut action
1704         // should be visible.
1705         QCOMPARE( //
1706             myDialog->d_pointer->m_oklchSpinBoxGamutAction->isVisible(), //
1707             false);
1708         QCOMPARE( //
1709             myDialog->d_pointer->m_oklchSpinBoxGamutAction->isVisible(), //
1710             false);
1711 
1712         constexpr int iterations = 15;
1713 
1714         auto &myOklchSpinBox = myDialog->d_pointer->m_oklchSpinBox;
1715         myOklchSpinBox->setFocus();
1716         QTest::keyClick(myOklchSpinBox, Qt::Key_Tab);
1717         // Now, the focus should be on the chroma value.
1718         for (int i = 0; i < iterations; ++i) {
1719             QTest::keyClick(myOklchSpinBox, Qt::Key_PageUp);
1720         }
1721         QCOMPARE( //
1722             myDialog->d_pointer->m_oklchSpinBoxGamutAction->isVisible(), //
1723             true);
1724         for (int i = 0; i < iterations; ++i) {
1725             QTest::keyClick(myOklchSpinBox, Qt::Key_PageDown);
1726         }
1727         QCOMPARE( //
1728             myDialog->d_pointer->m_oklchSpinBoxGamutAction->isVisible(), //
1729             false);
1730     }
1731 
1732 #ifndef MSVC_DLL
1733     void testReadHlcNumericValues()
1734     {
1735         QScopedPointer<ColorDialog> myDialog( //
1736             new ColorDialog(m_srgbBuildinColorSpace));
1737         QList<double> myValues = //
1738             myDialog->d_pointer->m_ciehlcD50SpinBox->sectionValues();
1739 
1740         // Test with a normal value
1741         myValues[0] = 10;
1742         myValues[1] = 11;
1743         myValues[2] = 12;
1744         myDialog->d_pointer->m_ciehlcD50SpinBox->setSectionValues(myValues);
1745         myDialog->d_pointer->readHlcNumericValues();
1746         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::CielchD50).third, 10);
1747         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::CielchD50).first, 11);
1748         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::CielchD50).second, 12);
1749 
1750         // Test with an out-of-gamut value. Hue and lightness should not change.
1751         myValues[0] = 10;
1752         myValues[1] = 11;
1753         myValues[2] = 50;
1754         myDialog->d_pointer->m_ciehlcD50SpinBox->setSectionValues(myValues);
1755         myDialog->d_pointer->readHlcNumericValues();
1756         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::CielchD50).third, 10);
1757         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::CielchD50).first, 11);
1758     }
1759 #endif
1760 
1761 #ifndef MSVC_DLL
1762     void testReadOklchNumericValues()
1763     {
1764         QScopedPointer<ColorDialog> myDialog( //
1765             new ColorDialog(m_srgbBuildinColorSpace));
1766         QList<double> myValues = //
1767             myDialog->d_pointer->m_oklchSpinBox->sectionValues();
1768 
1769         // Test with a normal value
1770         myValues[0] = 0.25;
1771         myValues[1] = 0.05;
1772         myValues[2] = 3;
1773         myDialog->d_pointer->m_oklchSpinBox->setSectionValues(myValues);
1774         myDialog->d_pointer->readOklchNumericValues();
1775         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::OklchD65).first, 0.25);
1776         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::OklchD65).second, 0.05);
1777         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::OklchD65).third, 3);
1778 
1779         // Test with an out-of-gamut value. Hue and lightness should not change.
1780         myValues[0] = 0.25;
1781         myValues[1] = 0.2;
1782         myValues[2] = 3;
1783         myDialog->d_pointer->m_oklchSpinBox->setSectionValues(myValues);
1784         myDialog->d_pointer->readOklchNumericValues();
1785         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::OklchD65).first, 0.25);
1786         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::OklchD65).third, 3);
1787     }
1788 #endif
1789 
1790     void testReadHsvNumericValues()
1791     {
1792         QScopedPointer<ColorDialog> myDialog( //
1793             new ColorDialog(m_srgbBuildinColorSpace));
1794         QList<double> myValues = //
1795             myDialog->d_pointer->m_hsvSpinBox->sectionValues();
1796         myValues[0] = 10;
1797         myValues[1] = 11;
1798         myValues[2] = 12;
1799         myDialog->d_pointer->m_hsvSpinBox->setSectionValues(myValues);
1800         myDialog->d_pointer->readHsvNumericValues();
1801         QCOMPARE(qRound(myDialog->currentColor().hueF() * 360), 10);
1802         QCOMPARE(qRound(myDialog->currentColor().saturationF() * 100), 11);
1803         QCOMPARE(qRound(myDialog->currentColor().valueF() * 100), 12);
1804     }
1805 
1806     void testReadRgbHexValues()
1807     {
1808         QScopedPointer<ColorDialog> myDialog( //
1809             new ColorDialog(m_srgbBuildinColorSpace));
1810 
1811         // Test some value
1812         myDialog->d_pointer->m_rgbLineEdit->setText(QStringLiteral("#010203"));
1813         myDialog->d_pointer->readRgbHexValues();
1814         QCOMPARE(myDialog->currentColor().red(), 1);
1815         QCOMPARE(myDialog->currentColor().green(), 2);
1816         QCOMPARE(myDialog->currentColor().blue(), 3);
1817         QCOMPARE(myDialog->d_pointer->m_rgbLineEdit->text(), //
1818                  QStringLiteral("#010203"));
1819 
1820         // Test this value which is known to have triggered yet rounding errors!
1821         myDialog->d_pointer->m_rgbLineEdit->setText(QStringLiteral("#ff0000"));
1822         myDialog->d_pointer->readRgbHexValues();
1823         QCOMPARE(myDialog->currentColor().red(), 255);
1824         QCOMPARE(myDialog->currentColor().green(), 0);
1825         QCOMPARE(myDialog->currentColor().blue(), 0);
1826         QCOMPARE(myDialog->d_pointer->m_rgbLineEdit->text(), //
1827                  QStringLiteral("#ff0000"));
1828 
1829         // Test this value which is known to have triggered yet rounding errors!
1830         myDialog->d_pointer->m_rgbLineEdit->setText(QStringLiteral("#ef6c00"));
1831         myDialog->d_pointer->readRgbHexValues();
1832         QCOMPARE(myDialog->currentColor().red(), 239);
1833         QCOMPARE(myDialog->currentColor().green(), 108);
1834         QCOMPARE(myDialog->currentColor().blue(), 0);
1835         QCOMPARE(myDialog->d_pointer->m_rgbLineEdit->text(), //
1836                  QStringLiteral("#ef6c00"));
1837 
1838         // Test this value which is known to have triggered yet rounding errors!
1839         myDialog->d_pointer->m_rgbLineEdit->setText(QStringLiteral("#ffff00"));
1840         myDialog->d_pointer->readRgbHexValues();
1841         QCOMPARE(myDialog->currentColor().red(), 255);
1842         QCOMPARE(myDialog->currentColor().green(), 255);
1843         QCOMPARE(myDialog->currentColor().blue(), 0);
1844         QCOMPARE(myDialog->d_pointer->m_rgbLineEdit->text(), //
1845                  QStringLiteral("#ffff00"));
1846     }
1847 
1848     void testReadRgbNumericValues()
1849     {
1850         QScopedPointer<ColorDialog> myDialog( //
1851             new ColorDialog(m_srgbBuildinColorSpace));
1852         QList<double> myValues = //
1853             myDialog->d_pointer->m_rgbSpinBox->sectionValues();
1854         myValues[0] = 10;
1855         myValues[1] = 11;
1856         myValues[2] = 12;
1857         myDialog->d_pointer->m_rgbSpinBox->setSectionValues(myValues);
1858         myDialog->d_pointer->readRgbNumericValues();
1859         QCOMPARE(myDialog->currentColor().red(), 10);
1860         QCOMPARE(myDialog->currentColor().green(), 11);
1861         QCOMPARE(myDialog->currentColor().blue(), 12);
1862     }
1863 
1864 #ifndef MSVC_DLL
1865     void testSetCurrentOpaqueColor()
1866     {
1867         QScopedPointer<ColorDialog> myDialog( //
1868             new ColorDialog(m_srgbBuildinColorSpace));
1869         const auto myMultiColor = AbsoluteColor::allConversions( //
1870             ColorModel::CielchD50,
1871             GenericColor(30, 40, 50));
1872         myDialog->d_pointer->setCurrentOpaqueColor(myMultiColor, nullptr);
1873         QCOMPARE(myDialog->d_pointer->m_currentOpaqueColorAbs, myMultiColor);
1874         QList<double> myValues = //
1875             myDialog->d_pointer->m_rgbSpinBox->sectionValues();
1876         QCOMPARE(qRound(myValues.at(0)), 113);
1877         QCOMPARE(qRound(myValues.at(1)), 53);
1878         QCOMPARE(qRound(myValues.at(2)), 23);
1879     }
1880 #endif
1881 
1882     void testUpdateColorPatch()
1883     {
1884         QScopedPointer<ColorDialog> myDialog( //
1885             new ColorDialog(m_srgbBuildinColorSpace));
1886         myDialog->d_pointer->m_currentOpaqueColorRgb = //
1887             RgbColor::fromRgbQColor(QColor(1, 2, 3));
1888         myDialog->d_pointer->updateColorPatch();
1889         QCOMPARE(myDialog->d_pointer->m_colorPatch->color().red(), 1);
1890         QCOMPARE(myDialog->d_pointer->m_colorPatch->color().green(), 2);
1891         QCOMPARE(myDialog->d_pointer->m_colorPatch->color().blue(), 3);
1892         QCOMPARE(myDialog->d_pointer->m_colorPatch->color().alphaF(), //
1893                  myDialog->d_pointer->m_alphaGradientSlider->value());
1894     }
1895 
1896     void testSizeGrip()
1897     {
1898         // As this dialog can indeed be resized, the size grip should
1899         // be enabled. So, users can see the little triangle at the
1900         // right bottom of the dialog (or the left bottom on a
1901         // right-to-left layout). So, the user will be aware
1902         // that he can indeed resize this dialog, which is
1903         // important as the users are used to the default
1904         // platform dialog, which often does not allow resizing. Therefore,
1905         // by default, QDialog::isSizeGripEnabled() should be true.
1906         // NOTE: Some widget styles like Oxygen or Breeze leave the size grip
1907         // widget invisible; nevertheless it reacts on mouse events. Other
1908         // widget styles indeed show the size grip widget, like Fusion or
1909         // QtCurve.
1910         m_perceptualDialog.reset( //
1911             new ColorDialog(m_srgbBuildinColorSpace));
1912         QCOMPARE(m_perceptualDialog->isSizeGripEnabled(), true);
1913         m_perceptualDialog->show();
1914         QCOMPARE(m_perceptualDialog->isSizeGripEnabled(), true);
1915         m_perceptualDialog->hide();
1916         QCOMPARE(m_perceptualDialog->isSizeGripEnabled(), true);
1917     }
1918 
1919     void testLayoutDimensions()
1920     {
1921         m_perceptualDialog.reset( //
1922             new ColorDialog(m_srgbBuildinColorSpace));
1923         // Test default value
1924         QCOMPARE( //
1925             m_perceptualDialog->layoutDimensions(), //
1926             ColorDialog::DialogLayoutDimensions::Collapsed);
1927 
1928         // Test if values are correctly stored before showing
1929         m_perceptualDialog->setLayoutDimensions( //
1930             ColorDialog::DialogLayoutDimensions::Collapsed);
1931         QCOMPARE( //
1932             m_perceptualDialog->layoutDimensions(), //
1933             ColorDialog::DialogLayoutDimensions::Collapsed);
1934         m_perceptualDialog->setLayoutDimensions( //
1935             ColorDialog::DialogLayoutDimensions::Expanded);
1936         QCOMPARE( //
1937             m_perceptualDialog->layoutDimensions(), //
1938             ColorDialog::DialogLayoutDimensions::Expanded);
1939         m_perceptualDialog->setLayoutDimensions( //
1940             ColorDialog::DialogLayoutDimensions::ScreenSizeDependent);
1941         QCOMPARE( //
1942             m_perceptualDialog->layoutDimensions(), //
1943             ColorDialog::DialogLayoutDimensions::ScreenSizeDependent);
1944 
1945         // Test if values are correctly stored after showing
1946         m_perceptualDialog->show();
1947         m_perceptualDialog->setLayoutDimensions( //
1948             ColorDialog::DialogLayoutDimensions::Collapsed);
1949         QCOMPARE( //
1950             m_perceptualDialog->layoutDimensions(), //
1951             ColorDialog::DialogLayoutDimensions::Collapsed);
1952         m_perceptualDialog->setLayoutDimensions( //
1953             ColorDialog::DialogLayoutDimensions::Expanded);
1954         QCOMPARE( //
1955             m_perceptualDialog->layoutDimensions(), //
1956             ColorDialog::DialogLayoutDimensions::Expanded);
1957         m_perceptualDialog->setLayoutDimensions( //
1958             ColorDialog::DialogLayoutDimensions::ScreenSizeDependent);
1959         QCOMPARE( //
1960             m_perceptualDialog->layoutDimensions(), //
1961             ColorDialog::DialogLayoutDimensions::ScreenSizeDependent);
1962     }
1963 
1964     void testApplyLayoutDimensions()
1965     {
1966         m_perceptualDialog.reset( //
1967             new ColorDialog(m_srgbBuildinColorSpace));
1968         // Test default value
1969         QCOMPARE( //
1970             m_perceptualDialog->layoutDimensions(), //
1971             ColorDialog::DialogLayoutDimensions::Collapsed);
1972 
1973         m_perceptualDialog->d_pointer->m_layoutDimensions = //
1974             ColorDialog::DialogLayoutDimensions::Collapsed;
1975         m_perceptualDialog->d_pointer->applyLayoutDimensions();
1976         int collapsedWidth = m_perceptualDialog->width();
1977 
1978         m_perceptualDialog->d_pointer->m_layoutDimensions = //
1979             ColorDialog::DialogLayoutDimensions::Expanded;
1980         m_perceptualDialog->d_pointer->applyLayoutDimensions();
1981         int expandedWidth = m_perceptualDialog->width();
1982 
1983         QVERIFY2(collapsedWidth < expandedWidth,
1984                  "Verify that collapsed width of the dialog is smaller than "
1985                  "the expanded width.");
1986     }
1987 
1988     void testLayoutDimensionsChanged()
1989     {
1990         m_perceptualDialog.reset( //
1991             new ColorDialog(m_srgbBuildinColorSpace));
1992         m_perceptualDialog->setLayoutDimensions( //
1993             ColorDialog::DialogLayoutDimensions::Collapsed);
1994         QSignalSpy spyPerceptualDialog(
1995             // QObject to spy:
1996             m_perceptualDialog.data(),
1997             // Signal to spy:
1998             &ColorDialog::layoutDimensionsChanged);
1999         // Setting a different DialogLayoutDimensions will emit a signal
2000         m_perceptualDialog->setLayoutDimensions( //
2001             ColorDialog::DialogLayoutDimensions::Expanded);
2002         QCOMPARE(spyPerceptualDialog.count(), 1);
2003         // Setting the same DialogLayoutDimensions will not emit a signal again
2004         m_perceptualDialog->setLayoutDimensions( //
2005             ColorDialog::DialogLayoutDimensions::Expanded);
2006         QCOMPARE(spyPerceptualDialog.count(), 1);
2007     }
2008 
2009     void testRoundingErrors_data()
2010     {
2011         QTest::addColumn<QColor>("color");
2012         QTest::newRow("Qt::yellow") << QColor(Qt::yellow);
2013         QColorFloatType red = 1;
2014         QColorFloatType green = 1;
2015         QColorFloatType blue = 0;
2016         while (blue < 1) {
2017             QTest::newRow( //
2018                 QStringLiteral("RGB %1 %2 %3") //
2019                     .arg(red) //
2020                     .arg(green) //
2021                     .arg(blue) //
2022                     .toUtf8() //
2023                     .data()) //
2024                 << QColor::fromRgbF(red, green, blue);
2025             blue += 0.1f;
2026         }
2027     }
2028 
2029     void testRoundingErrors()
2030     {
2031         QFETCH(QColor, color);
2032 
2033         // Moving around between the widgets with the Tab key should
2034         // never trigger a value change. (There could be a value
2035         // change because of rounding errors if the value gets updated
2036         // after the focus leaves, even though no editing has been
2037         // done. This would not be correct, and this test controls this.)
2038 
2039         m_perceptualDialog.reset( //
2040             new ColorDialog(m_srgbBuildinColorSpace));
2041         m_perceptualDialog->setCurrentColor(color);
2042         m_perceptualDialog->show();
2043         QApplication::setActiveWindow(m_perceptualDialog.data());
2044         // Using a QList instead of a simple QWidget* to make sure
2045         // not to have infinite loops even is focus passing might be
2046         // broken and never returns to the original focus.
2047         QList<QWidget *> oldFocusWidgets;
2048         for (int i = 0; //
2049              i < m_perceptualDialog->d_pointer->m_tabWidget->count(); //
2050              i++ //
2051         ) {
2052             m_perceptualDialog->d_pointer->m_tabWidget->setCurrentIndex(i);
2053             oldFocusWidgets.clear();
2054             const QColor oldColor = m_perceptualDialog->currentColor();
2055             const auto oldOpaqueColorAbs = //
2056                 m_perceptualDialog->d_pointer->m_currentOpaqueColorAbs;
2057             const auto oldOpaqueColorRgb = //
2058                 m_perceptualDialog->d_pointer->m_currentOpaqueColorRgb;
2059             bool focusPassingIsWorking = true;
2060             while ( //
2061                 focusPassingIsWorking //
2062                 && (!oldFocusWidgets.contains(QApplication::focusWidget())) //
2063             ) {
2064                 oldFocusWidgets.append(QApplication::focusWidget());
2065                 focusPassingIsWorking = m_perceptualDialog->focusNextChild();
2066                 QCOMPARE(oldColor, m_perceptualDialog->currentColor());
2067                 QVERIFY( //
2068                     oldOpaqueColorAbs //
2069                     == m_perceptualDialog->d_pointer->m_currentOpaqueColorAbs);
2070                 QVERIFY( //
2071                     oldOpaqueColorRgb //
2072                     == m_perceptualDialog->d_pointer->m_currentOpaqueColorRgb);
2073             }
2074         };
2075     }
2076 
2077     void testYellowRounding()
2078     {
2079         // During development was observed a particular bug for which
2080         // we test here.
2081 
2082         // As we expect rounding errors, we define a tolerance range,
2083         // which is used both for the assertions and for the actual test.
2084         // This is necessary to guarantee that this test does not produce
2085         // false-positives just because the rounding behaviour of the
2086         // library has changed.
2087         const int toleranceRange = 1;
2088 
2089         // Create a ColorDialog
2090         m_perceptualDialog.reset( //
2091             new ColorDialog(m_srgbBuildinColorSpace));
2092 
2093         // Start with Qt::yellow as initial color.
2094         // If this RGB value is interpreted in the sRGB (LittleCMS build-in)
2095         // profile, it has a particular property. Because of the irregular
2096         // shape of the sRGB color space at this position, thinking in
2097         // LCH values, when reducing (!) the chroma step-by-step, we run
2098         // out-of-gamut, before going again in-gamut at even lower chroma
2099         // values.
2100         m_perceptualDialog->setCurrentColor(QColor(Qt::yellow));
2101         // The value is also converted to HLC 100°, 98%, 95 (rounded)
2102         // visible in the HLC spin box.
2103         QList<double> hlc = //
2104             m_perceptualDialog->d_pointer->m_ciehlcD50SpinBox->sectionValues();
2105         QVERIFY(hlc.at(0) >= 100 - toleranceRange); // assertion
2106         QVERIFY(hlc.at(0) <= 100 + toleranceRange); // assertion
2107         QVERIFY(hlc.at(1) >= 98 - toleranceRange); // assertion
2108         QVERIFY(hlc.at(1) <= 98 + toleranceRange); // assertion
2109         QVERIFY(hlc.at(2) >= 95 - toleranceRange); // assertion
2110         QVERIFY(hlc.at(2) <= 95 + toleranceRange); // assertion
2111         // Now, the user clicks on the “Apply” button within the HLC spin box.
2112         // We simulate this by simply calling the slot that is connected
2113         // to this action:
2114         m_perceptualDialog->d_pointer->readHlcNumericValues();
2115         // Now, during development there was a bug observed: The buggy
2116         // behaviour was that the chroma value was changed from 95 to 24.
2117         // The expected result was that the chroma value only changes
2118         // slightly because of rounding (or ideally not at all).
2119         hlc = m_perceptualDialog->d_pointer->m_ciehlcD50SpinBox->sectionValues();
2120         QVERIFY(hlc.at(2) >= 95 - toleranceRange);
2121         QVERIFY(hlc.at(2) <= 95 + toleranceRange);
2122     }
2123 
2124     void testBlackHSV()
2125     {
2126         // In the HSV color space, if V is 0 then the color is black.
2127         // Both, H and S are meaningless. When converting from other
2128         // color spaces, they get probably a default value. However,
2129         // when the user is editing the HSV spin box, we does not expect
2130         // that H or S change when switching from one section to another
2131         // or when the focus leaves. Make sure that H and S are preserved
2132         // during editing even if V becomes 0:
2133 
2134         // Create a ColorDialog
2135         m_perceptualDialog.reset( //
2136             new ColorDialog(m_srgbBuildinColorSpace));
2137 
2138         const QList<double> hsvTestData{201, 33, 0};
2139         m_perceptualDialog->d_pointer->m_hsvSpinBox->setSectionValues( //
2140             hsvTestData);
2141         QCOMPARE( //
2142             m_perceptualDialog->d_pointer->m_hsvSpinBox->sectionValues(), //
2143             hsvTestData);
2144         m_perceptualDialog->d_pointer->readHsvNumericValues();
2145         QCOMPARE( //
2146             m_perceptualDialog->d_pointer->m_hsvSpinBox->sectionValues(), //
2147             hsvTestData);
2148     }
2149 
2150     void testRoundingMultipleError()
2151     {
2152         // This is a test for a bug discovered during development.
2153 
2154         // Create a ColorDialog:
2155         m_perceptualDialog.reset( //
2156             new ColorDialog(m_srgbBuildinColorSpace));
2157 
2158         // The user puts into the HLC spin box the value 100° 98% 94:
2159         m_perceptualDialog->d_pointer->m_ciehlcD50SpinBox->setSectionValues( //
2160             QList<double>{100, 98, 94});
2161         // This is an out-of-gamut color which is not corrected until
2162         // the focus will leave the widget or the Return key is pressed.
2163         // A nearby in-gamut color is around 100° 98% 24; this color
2164         // is used internally to perform the conversion to RGB and other
2165         // color spaces. (It is however still not visible in the HLC
2166         // spin box.)
2167         //
2168         // The RGB spin box becomes:
2169         const QList<double> expectedRgbValues{255, 251, 202};
2170         QCOMPARE( //
2171             m_perceptualDialog->d_pointer->m_rgbSpinBox->sectionValues(), //
2172             expectedRgbValues);
2173         // Now, the user finishes the editing process (the focus leaves
2174         // the widget or the Return key is pressed or the action button
2175         // is clicked):
2176         m_perceptualDialog->d_pointer->updateHlcButBlockSignals();
2177         // The buggy result during development phase was an RGB value
2178         // of 252 254 4. Why?
2179         // - The internal value was around 100° 97% 94, but not exactly.
2180         // - Now, the exact (!) value of 100° 97% 94 is applied, and this
2181         //   one, converted to RGB, triggers a different rounding.
2182         // The expected result is however still the very same RGB value
2183         // as above:
2184         QCOMPARE( //
2185             m_perceptualDialog->d_pointer->m_rgbSpinBox->sectionValues(), //
2186             expectedRgbValues);
2187     }
2188 
2189 #ifndef MSVC_DLL
2190     void testRgbHexRounding()
2191     {
2192         // This is a test for a bug discovered during development.
2193         // QColor can produce a QString that contains a hexadecimal
2194         // (integer) representation of the color, just as used in
2195         // HTML. Example: #0000FF is blue. When rounding to
2196         // integers, apparently it does not use round(), but floor().
2197         // That is not useful and not inconsistent with the rest of our
2198         // dialog. We want correct rounding!
2199 
2200         // Create a ColorDialog:
2201         m_perceptualDialog.reset( //
2202             new ColorDialog(m_srgbBuildinColorSpace));
2203 
2204         // Set a color that triggers the rounding error:
2205         GenericColor testColorLch{97, 94, 100};
2206         m_perceptualDialog->d_pointer->setCurrentOpaqueColor(
2207             // Color:
2208             AbsoluteColor::allConversions( //
2209                 ColorModel::CielchD50, //
2210                 testColorLch),
2211             // Widget to ignore:
2212             nullptr);
2213 
2214         // Get the actual result
2215         QColor actualHex;
2216         actualHex.setNamedColor( //
2217             m_perceptualDialog->d_pointer->m_rgbLineEdit->text());
2218 
2219         // Get the expected result (We assume our own RGB spin box rounds
2220         // correctly.)
2221         const QList<double> rgbList =
2222             // The the values from the MultiSpinBox:
2223             m_perceptualDialog->d_pointer->m_rgbSpinBox->sectionValues();
2224         QColor expectedHex = QColor::fromRgb(
2225             // The MultiSpinBox might have decimal places, so we round
2226             // here again.
2227             qRound(rgbList.at(0)),
2228             qRound(rgbList.at(1)),
2229             qRound(rgbList.at(2)));
2230 
2231         // Compare
2232         QCOMPARE(actualHex, expectedHex);
2233     }
2234 #endif
2235 
2236 #ifndef MSVC_DLL
2237     void testBugMaximumLightness()
2238     {
2239         QScopedPointer<QTemporaryFile> wideGamutProfile(
2240             // Create a temporary actual file…
2241             QTemporaryFile::createNativeFile(
2242                 // …from the content of this resource:
2243                 QStringLiteral(":/testbed/Compact-ICC-Profiles/Compact-ICC-Profiles/profiles/WideGamutCompat-v4.icc")));
2244         if (wideGamutProfile.isNull()) {
2245             throw 0;
2246         }
2247         // This test looks for a bug that was seen during development
2248         // phase. When using WideGamutRGB and raising the lightness
2249         // slider up to 100%: Bug behaviour: the color switches
2250         // to 0% lightness. Expected behaviour: the color has almost
2251         // 100% lightness.
2252         auto myColorSpace = RgbColorSpace::createFromFile( //
2253             wideGamutProfile->fileName());
2254         QCOMPARE(myColorSpace.isNull(), false); // assertion
2255         m_perceptualDialog.reset( //
2256             new ColorDialog(myColorSpace));
2257         QTest::keyClick( //
2258             m_perceptualDialog->d_pointer->m_lchLightnessSelector, //
2259             Qt::Key_End);
2260         QVERIFY( //
2261             m_perceptualDialog->d_pointer->m_currentOpaqueColorAbs.value(ColorModel::CielchD50).first > 95);
2262     }
2263 #endif
2264 
2265     void testExplicitShortcutsExpanded()
2266     {
2267         // Make sure to have mnemonics (like Qt::ALT+Qt::Key_X for "E&xit")
2268         // enabled, also on platforms that disable it by default.
2269         qt_set_sequence_auto_mnemonic(true);
2270 
2271         setTranslation(QCoreApplication::instance(), //
2272                        QLocale(QLocale::English).uiLanguages());
2273         // Create a ColorDialog:
2274         m_perceptualDialog.reset( //
2275             new ColorDialog(m_srgbBuildinColorSpace));
2276         m_perceptualDialog->setLayoutDimensions( //
2277             ColorDialog::DialogLayoutDimensions::Expanded);
2278         m_perceptualDialog->show();
2279         QApplication::setActiveWindow(m_perceptualDialog.data());
2280         auto &d = m_perceptualDialog->d_pointer;
2281 
2282         d->m_tabWidget->setFocus();
2283         QTest::keyClick(QApplication::focusWidget(), //
2284                         Qt::Key_B, //
2285                         Qt::AltModifier);
2286         QCOMPARE(d->m_tabWidget->currentIndex(), //
2287                  d->m_tabWidget->indexOf(d->m_swatchBookWrapperWidget));
2288 
2289         d->m_tabWidget->setFocus();
2290         QTest::keyClick(QApplication::focusWidget(), //
2291                         Qt::Key_H, //
2292                         Qt::AltModifier);
2293         QCOMPARE(d->m_tabWidget->currentIndex(), //
2294                  d->m_tabWidget->indexOf(d->m_hueFirstWrapperWidget));
2295 
2296         d->m_tabWidget->setFocus();
2297         QTest::keyClick(QApplication::focusWidget(), //
2298                         Qt::Key_L, //
2299                         Qt::AltModifier);
2300         QCOMPARE(d->m_tabWidget->currentIndex(), //
2301                  d->m_tabWidget->indexOf(d->m_lightnessFirstWrapperWidget));
2302 
2303         // Return to "Basic colors" tab
2304         d->m_tabWidget->setFocus();
2305         QTest::keyClick(QApplication::focusWidget(), //
2306                         Qt::Key_B, //
2307                         Qt::AltModifier);
2308         QCOMPARE(d->m_tabWidget->currentIndex(), //
2309                  d->m_tabWidget->indexOf(d->m_swatchBookWrapperWidget));
2310 
2311         // The shortcut for the "Numerical" works.
2312         d->m_tabWidget->setFocus();
2313         QTest::keyClick(QApplication::focusWidget(), //
2314                         Qt::Key_N, //
2315                         Qt::AltModifier);
2316         QCOMPARE(d->m_tabWidget->currentIndex(), //
2317                  d->m_tabWidget->indexOf(d->m_swatchBookWrapperWidget));
2318 
2319         const auto indexOfSwatchBookTab = //
2320             d->m_tabWidget->indexOf(d->m_swatchBookWrapperWidget);
2321         const auto toolTip = d->m_tabWidget->tabToolTip(indexOfSwatchBookTab);
2322         const auto toolTipContainsUnderline = //
2323             toolTip.contains(QStringLiteral("<u>"));
2324         QCOMPARE(toolTipContainsUnderline, true);
2325     }
2326 
2327     void testExplicitShortcutsCollapsed()
2328     {
2329         // Make sure to have mnemonics (like Qt::ALT+Qt::Key_X for "E&xit")
2330         // enabled, also on platforms that disable it by default.
2331         qt_set_sequence_auto_mnemonic(true);
2332 
2333         setTranslation(QCoreApplication::instance(), //
2334                        QLocale(QLocale::English).uiLanguages());
2335         // Create a ColorDialog:
2336         m_perceptualDialog.reset( //
2337             new ColorDialog(m_srgbBuildinColorSpace));
2338         m_perceptualDialog->setLayoutDimensions( //
2339             ColorDialog::DialogLayoutDimensions::Collapsed);
2340         m_perceptualDialog->show();
2341         QApplication::setActiveWindow(m_perceptualDialog.data());
2342         auto &d = m_perceptualDialog->d_pointer;
2343 
2344         d->m_tabWidget->setFocus();
2345         QTest::keyClick(QApplication::focusWidget(), //
2346                         Qt::Key_B, //
2347                         Qt::AltModifier);
2348         QCOMPARE(d->m_tabWidget->currentIndex(), //
2349                  d->m_tabWidget->indexOf(d->m_swatchBookWrapperWidget));
2350 
2351         d->m_tabWidget->setFocus();
2352         QTest::keyClick(QApplication::focusWidget(), //
2353                         Qt::Key_H, //
2354                         Qt::AltModifier);
2355         QCOMPARE(d->m_tabWidget->currentIndex(), //
2356                  d->m_tabWidget->indexOf(d->m_hueFirstWrapperWidget));
2357 
2358         d->m_tabWidget->setFocus();
2359         QTest::keyClick(QApplication::focusWidget(), //
2360                         Qt::Key_L, //
2361                         Qt::AltModifier);
2362         QCOMPARE(d->m_tabWidget->currentIndex(), //
2363                  d->m_tabWidget->indexOf(d->m_lightnessFirstWrapperWidget));
2364 
2365         // Return to "Basic colors" tab
2366         d->m_tabWidget->setFocus();
2367         QTest::keyClick(QApplication::focusWidget(), //
2368                         Qt::Key_B, //
2369                         Qt::AltModifier);
2370         QCOMPARE(d->m_tabWidget->currentIndex(), //
2371                  d->m_tabWidget->indexOf(d->m_swatchBookWrapperWidget));
2372 
2373         // The shortcut for the "Numerical" works.
2374         d->m_tabWidget->setFocus();
2375         QTest::keyClick(QApplication::focusWidget(), //
2376                         Qt::Key_N, //
2377                         Qt::AltModifier);
2378         QCOMPARE(d->m_tabWidget->currentIndex(), //
2379                  d->m_tabWidget->indexOf(d->m_numericalWidget));
2380 
2381         const auto indexOfSwatchBookTab = //
2382             d->m_tabWidget->indexOf(d->m_swatchBookWrapperWidget);
2383         const auto toolTip = d->m_tabWidget->tabToolTip(indexOfSwatchBookTab);
2384         const auto toolTipContainsUnderline = //
2385             toolTip.contains(QStringLiteral("<u>"));
2386         QCOMPARE(toolTipContainsUnderline, true);
2387     }
2388 
2389     void testExplicitShortcutsExpandedDisabled()
2390     {
2391         // Make sure to have mnemonics (like Qt::ALT+Qt::Key_X for "E&xit")
2392         // disabled, also on platforms that enable it by default.
2393         qt_set_sequence_auto_mnemonic(false);
2394 
2395         setTranslation(QCoreApplication::instance(), //
2396                        QLocale(QLocale::English).uiLanguages());
2397         // Create a ColorDialog:
2398         m_perceptualDialog.reset( //
2399             new ColorDialog(m_srgbBuildinColorSpace));
2400         m_perceptualDialog->setLayoutDimensions( //
2401             ColorDialog::DialogLayoutDimensions::Expanded);
2402         m_perceptualDialog->show();
2403         QApplication::setActiveWindow(m_perceptualDialog.data());
2404         auto &d = m_perceptualDialog->d_pointer;
2405 
2406         const auto originalIndex = d->m_tabWidget->currentIndex();
2407 
2408         // NOTE When mnemonics are disabled, all these key clicks should
2409         // not have any effect.
2410 
2411         d->m_tabWidget->setFocus();
2412         QTest::keyClick(QApplication::focusWidget(), //
2413                         Qt::Key_B, //
2414                         Qt::AltModifier);
2415         QCOMPARE(d->m_tabWidget->currentIndex(), //
2416                  originalIndex);
2417 
2418         d->m_tabWidget->setFocus();
2419         QTest::keyClick(QApplication::focusWidget(), //
2420                         Qt::Key_H, //
2421                         Qt::AltModifier);
2422         QCOMPARE(d->m_tabWidget->currentIndex(), //
2423                  originalIndex);
2424 
2425         d->m_tabWidget->setFocus();
2426         QTest::keyClick(QApplication::focusWidget(), //
2427                         Qt::Key_L, //
2428                         Qt::AltModifier);
2429         QCOMPARE(d->m_tabWidget->currentIndex(), //
2430                  originalIndex);
2431 
2432         d->m_tabWidget->setFocus();
2433         QTest::keyClick(QApplication::focusWidget(), //
2434                         Qt::Key_N, //
2435                         Qt::AltModifier);
2436         QCOMPARE(d->m_tabWidget->currentIndex(), //
2437                  originalIndex);
2438 
2439         const auto indexOfSwatchBookTab = //
2440             d->m_tabWidget->indexOf(d->m_swatchBookWrapperWidget);
2441         const auto toolTip = d->m_tabWidget->tabToolTip(indexOfSwatchBookTab);
2442         const auto toolTipContainsUnderline = //
2443             toolTip.contains(QStringLiteral("<u>"));
2444         QCOMPARE(toolTipContainsUnderline, false);
2445     }
2446 
2447     void testExplicitShortcutsCollapsedDisabled()
2448     {
2449         // Make sure to have mnemonics (like Qt::ALT+Qt::Key_X for "E&xit")
2450         // disabled, also on platforms that enable it by default.
2451         qt_set_sequence_auto_mnemonic(false);
2452 
2453         setTranslation(QCoreApplication::instance(), //
2454                        QLocale(QLocale::English).uiLanguages());
2455         // Create a ColorDialog:
2456         m_perceptualDialog.reset( //
2457             new ColorDialog(m_srgbBuildinColorSpace));
2458         m_perceptualDialog->setLayoutDimensions( //
2459             ColorDialog::DialogLayoutDimensions::Collapsed);
2460         m_perceptualDialog->show();
2461         QApplication::setActiveWindow(m_perceptualDialog.data());
2462         auto &d = m_perceptualDialog->d_pointer;
2463 
2464         const auto originalIndex = d->m_tabWidget->currentIndex();
2465 
2466         // NOTE When mnemonics are disabled, all these key clicks should
2467         // not have any effect.
2468 
2469         d->m_tabWidget->setFocus();
2470         QTest::keyClick(QApplication::focusWidget(), //
2471                         Qt::Key_B, //
2472                         Qt::AltModifier);
2473         QCOMPARE(d->m_tabWidget->currentIndex(), //
2474                  originalIndex);
2475 
2476         d->m_tabWidget->setFocus();
2477         QTest::keyClick(QApplication::focusWidget(), //
2478                         Qt::Key_H, //
2479                         Qt::AltModifier);
2480         QCOMPARE(d->m_tabWidget->currentIndex(), //
2481                  originalIndex);
2482 
2483         d->m_tabWidget->setFocus();
2484         QTest::keyClick(QApplication::focusWidget(), //
2485                         Qt::Key_L, //
2486                         Qt::AltModifier);
2487         QCOMPARE(d->m_tabWidget->currentIndex(), //
2488                  originalIndex);
2489 
2490         d->m_tabWidget->setFocus();
2491         QTest::keyClick(QApplication::focusWidget(), //
2492                         Qt::Key_N, //
2493                         Qt::AltModifier);
2494         QCOMPARE(d->m_tabWidget->currentIndex(), //
2495                  originalIndex);
2496 
2497         const auto indexOfSwatchBookTab = //
2498             d->m_tabWidget->indexOf(d->m_swatchBookWrapperWidget);
2499         const auto toolTip = d->m_tabWidget->tabToolTip(indexOfSwatchBookTab);
2500         const auto toolTipContainsUnderline = //
2501             toolTip.contains(QStringLiteral("<u>"));
2502         QCOMPARE(toolTipContainsUnderline, false);
2503     }
2504 
2505     void testSnippet02()
2506     {
2507         snippet02();
2508     }
2509 
2510     void testSnippet03()
2511     {
2512         snippet03();
2513     }
2514 
2515     void testSnippet05()
2516     {
2517         TestColorDialogSnippetClass mySnippets;
2518         mySnippets.testSnippet05();
2519     }
2520 
2521     void benchmarkCreateAndShowPerceptualDialog()
2522     {
2523         m_perceptualDialog.reset(nullptr);
2524         QBENCHMARK {
2525             m_perceptualDialog.reset( //
2526                 new ColorDialog(m_srgbBuildinColorSpace));
2527             m_perceptualDialog->show();
2528             m_perceptualDialog->repaint();
2529             m_perceptualDialog.reset(nullptr);
2530         }
2531     }
2532 
2533     void benchmarkCreateAndShowMaximizedPerceptualDialog()
2534     {
2535         m_perceptualDialog.reset(nullptr);
2536         QBENCHMARK {
2537             m_perceptualDialog.reset( //
2538                 new ColorDialog(m_srgbBuildinColorSpace));
2539             m_perceptualDialog->showMaximized();
2540             m_perceptualDialog->repaint();
2541             m_perceptualDialog.reset(nullptr);
2542         }
2543     }
2544 
2545     void benchmarkCreateAndShowQColorDialog()
2546     {
2547         m_qDialog.reset(nullptr);
2548         QBENCHMARK {
2549             m_qDialog.reset(new QColorDialog);
2550             m_qDialog->show();
2551             m_qDialog->repaint();
2552             m_perceptualDialog.reset(nullptr);
2553         }
2554     }
2555 
2556     void benchmarkChangeColorPerceptualHueBased()
2557     {
2558         setTranslation(QCoreApplication::instance(), //
2559                        QLocale(QLocale::English).uiLanguages());
2560         m_perceptualDialog.reset( //
2561             new ColorDialog(m_srgbBuildinColorSpace));
2562         m_perceptualDialog->show();
2563 
2564         QTabWidget *theTabWidget = //
2565             m_perceptualDialog->findChild<QTabWidget *>();
2566         QVERIFY2(theTabWidget != nullptr, //
2567                  "Assert that theTabWidget has actually been found.");
2568         constexpr int myIndex = 1;
2569         // Assert that we got the correct tab widget:
2570         QCOMPARE(theTabWidget->tabToolTip(myIndex), //
2571                  QStringLiteral("<a/><u>H</u>ue-based"));
2572         theTabWidget->setCurrentIndex(myIndex);
2573 
2574         QBENCHMARK {
2575             m_perceptualDialog->setCurrentColor(Qt::green);
2576             m_perceptualDialog->repaint();
2577             m_perceptualDialog->setCurrentColor(Qt::blue);
2578             m_perceptualDialog->repaint();
2579             m_perceptualDialog->setCurrentColor(Qt::yellow);
2580             m_perceptualDialog->repaint();
2581         }
2582     }
2583 
2584     void benchmarkChangeColorPerceptualLightnessBased()
2585     {
2586         setTranslation(QCoreApplication::instance(), //
2587                        QLocale(QLocale::English).uiLanguages());
2588         m_perceptualDialog.reset( //
2589             new ColorDialog(m_srgbBuildinColorSpace));
2590         m_perceptualDialog->show();
2591 
2592         QTabWidget *theTabWidget = //
2593             m_perceptualDialog->findChild<QTabWidget *>();
2594         QVERIFY2(theTabWidget != nullptr, //
2595                  "Assert that theTabWidget has actually been found.");
2596         constexpr int myIndex = 2;
2597         // Assert that we got the correct tab widget:
2598         QCOMPARE(theTabWidget->tabToolTip(myIndex), //
2599                  QStringLiteral("<a/><u>L</u>ightness-based"));
2600         theTabWidget->setCurrentIndex(myIndex);
2601 
2602         QBENCHMARK {
2603             m_perceptualDialog->setCurrentColor(Qt::green);
2604             m_perceptualDialog->repaint();
2605             m_perceptualDialog->setCurrentColor(Qt::blue);
2606             m_perceptualDialog->repaint();
2607             m_perceptualDialog->setCurrentColor(Qt::yellow);
2608             m_perceptualDialog->repaint();
2609         }
2610     }
2611 
2612     void benchmarkChangeColorQColorDialog()
2613     {
2614         m_qDialog.reset(new QColorDialog);
2615         m_qDialog->show();
2616         QBENCHMARK {
2617             m_qDialog->setCurrentColor(Qt::green);
2618             m_qDialog->repaint();
2619             m_qDialog->setCurrentColor(Qt::blue);
2620             m_qDialog->repaint();
2621             m_qDialog->setCurrentColor(Qt::yellow);
2622             m_qDialog->repaint();
2623         }
2624     }
2625 
2626     // The last unit tests are those who need to change the locale.
2627     // To avoid side-effects, these unit tests are the last ones.
2628 
2629     void testChangeEventRetranslate()
2630     {
2631         initializeTranslation(QCoreApplication::instance(), //
2632                               QLocale(QLocale::English).uiLanguages());
2633         m_perceptualDialog.reset( //
2634             new ColorDialog(m_srgbBuildinColorSpace));
2635 
2636         // We test various translations, because we do not know the locale
2637         // of the system on which this unit test will run. As there might
2638         // be some coincidence between QLocale::system() and QLocale(),
2639         // we want to be sure and therefore test three translations.
2640 
2641         initializeTranslation(QCoreApplication::instance(), //
2642                               QLocale(QLocale::Dutch).uiLanguages());
2643         {
2644             QEvent temp(QEvent::LanguageChange);
2645             QCoreApplication::sendEvent(m_perceptualDialog.data(), &temp);
2646         }
2647         QCOMPARE(m_perceptualDialog->d_pointer->m_buttonCancel->text(), //
2648                  QStringLiteral("&Annuleren"));
2649 
2650         initializeTranslation(QCoreApplication::instance(), //
2651                               QLocale(QLocale::Catalan).uiLanguages());
2652         {
2653             QEvent temp(QEvent::LanguageChange);
2654             QCoreApplication::sendEvent(m_perceptualDialog.data(), &temp);
2655         }
2656         QCOMPARE(m_perceptualDialog->d_pointer->m_buttonCancel->text(), //
2657                  QStringLiteral("&Cancel·la"));
2658 
2659         initializeTranslation(QCoreApplication::instance(), //
2660                               QLocale(QLocale::Spanish).uiLanguages());
2661         {
2662             QEvent temp(QEvent::LanguageChange);
2663             QCoreApplication::sendEvent(m_perceptualDialog.data(), &temp);
2664         }
2665         QCOMPARE(m_perceptualDialog->d_pointer->m_buttonCancel->text(), //
2666                  QStringLiteral("&Cancelar"));
2667     }
2668 
2669     void testChangeEventRetranslateButtons()
2670     {
2671         initializeTranslation(QCoreApplication::instance(), //
2672                               QLocale(QLocale::English).uiLanguages());
2673         m_perceptualDialog.reset( //
2674             new ColorDialog(m_srgbBuildinColorSpace));
2675 
2676         // There is a particular reason for testing the translation of
2677         // the dialog buttons. We are using standard-buttons generated
2678         // by QDialogButtonBox. These standard-buttons apparently are
2679         // re-translated by QDialogButtonBox, which hooks into LanuageChange
2680         // events of its parent widgets. (LanuageChange events originally
2681         // only go to the top-level widgets.) This is a problem, because
2682         // it might change the text of the buttons from our own translation
2683         // to the Qt translation. Furthermore, QDialogButtonBox uses
2684         // QLocale::system() while we use QLocale(), which means we could
2685         // end up with two different languages after calling retranslate()
2686         // if the implementation would not prevent this problem. Therefore,
2687         // here we test if the implementation actually prevents this problem.
2688 
2689         initializeTranslation(QCoreApplication::instance(), //
2690                               QLocale(QLocale::Dutch).uiLanguages());
2691         {
2692             QEvent temp(QEvent::LanguageChange);
2693             QCoreApplication::sendEvent(m_perceptualDialog.data(), &temp);
2694         }
2695         QCOMPARE(m_perceptualDialog->d_pointer->m_buttonCancel->text(), //
2696                  QStringLiteral("&Annuleren"));
2697 
2698         initializeTranslation(QCoreApplication::instance(), //
2699                               QLocale(QLocale::Catalan).uiLanguages());
2700         {
2701             QEvent temp(QEvent::LanguageChange);
2702             QCoreApplication::sendEvent(m_perceptualDialog.data(), &temp);
2703         }
2704         QCOMPARE(m_perceptualDialog->d_pointer->m_buttonCancel->text(), //
2705                  QStringLiteral("&Cancel·la"));
2706 
2707         initializeTranslation(QCoreApplication::instance(), //
2708                               QLocale(QLocale::Spanish).uiLanguages());
2709         {
2710             QEvent temp(QEvent::LanguageChange);
2711             QCoreApplication::sendEvent(m_perceptualDialog.data(), &temp);
2712         }
2713         QCOMPARE(m_perceptualDialog->d_pointer->m_buttonCancel->text(), //
2714                  QStringLiteral("&Cancelar"));
2715     }
2716 
2717     void testRestoreTab_data()
2718     {
2719         QTest::addColumn<ColorDialog::DialogLayoutDimensions>("layout");
2720 
2721         QTest::newRow("Collapsed") //
2722             << ColorDialog::DialogLayoutDimensions::Collapsed;
2723         QTest::newRow("Expanded") //
2724             << ColorDialog::DialogLayoutDimensions::Expanded;
2725         QTest::newRow("ScreenSizeDependent") //
2726             << ColorDialog::DialogLayoutDimensions::ScreenSizeDependent;
2727     }
2728 
2729     void testRestoreTab()
2730     {
2731         QFETCH(ColorDialog::DialogLayoutDimensions, layout);
2732         m_perceptualDialog.reset( //
2733             new ColorDialog(m_srgbBuildinColorSpace));
2734         m_perceptualDialog->setLayoutDimensions(layout);
2735         m_perceptualDialog->show(); // Needed for correct m_tabWidget->count()
2736 
2737         QList<int> testList;
2738         const auto tabCount = m_perceptualDialog->d_pointer->m_tabWidget->count();
2739         testList.reserve(tabCount + 1);
2740         for (int i = 0; i < tabCount; ++i) {
2741             testList.append(i);
2742         }
2743         testList.append(0); // Finally return again to the first tab.
2744 
2745         for (const auto i : std::as_const(testList)) {
2746             m_perceptualDialog->d_pointer->m_tabWidget->setCurrentIndex(i);
2747             m_perceptualDialog.reset( //
2748                 new ColorDialog(m_srgbBuildinColorSpace));
2749             // The last tab is only restored on show().
2750             m_perceptualDialog->setLayoutDimensions(layout);
2751             m_perceptualDialog->show();
2752             QCOMPARE(m_perceptualDialog->d_pointer->m_tabWidget->currentIndex(), i);
2753         }
2754     }
2755 
2756 private:
2757     void unused()
2758     {
2759         // These will not be called in the unit tests because getColor()
2760         // does not return without user interaction!
2761         // They are noted here to avoid a warning about “unused function”.
2762         snippet01();
2763         snippet04();
2764     }
2765 };
2766 
2767 } // namespace PerceptualColor
2768 
2769 QTEST_MAIN(PerceptualColor::TestColorDialog)
2770 // The following “include” is necessary because we do not use a header file:
2771 #include "testcolordialog.moc"