/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/


#include <QtCore/QCoreApplication>
#include <QtTest/QtTest>
#ifdef QT_GUI_LIB
#include <QtGui/QColor>
#include <QtGui/QImage>
#include <QtGui/QPixmap>
#include <QtGui/QVector2D>
#include <QtGui/QVector3D>
#include <QtGui/QVector4D>
#endif

/* XPM test data for QPixmap, QImage tests (use drag cursors as example) */

static const char * const xpmPixmapData1[] = {
"11 20 3 1",
".        c None",
"a        c #FFFFFF",
"X        c #000000", // X11 cursor is traditionally black
"aa.........",
"aXa........",
"aXXa.......",
"aXXXa......",
"aXXXXa.....",
"aXXXXXa....",
"aXXXXXXa...",
"aXXXXXXXa..",
"aXXXXXXXXa.",
"aXXXXXXXXXa",
"aXXXXXXaaaa",
"aXXXaXXa...",
"aXXaaXXa...",
"aXa..aXXa..",
"aa...aXXa..",
"a.....aXXa.",
"......aXXa.",
".......aXXa",
".......aXXa",
"........aa."};

static const char * const xpmPixmapData2[] = {
"11 20 4 1",
".        c None",
"a        c #FFFFFF",
"b        c #0000FF",
"X        c #000000",
"aab........",
"aXab.......",
"aXXab......",
"aXXXab.....",
"aXXXXab....",
"aXXXXXab...",
"aXXXXXXab..",
"aXXXXXXXa..",
"aXXXXXXXXa.",
"aXXXXXXXXXa",
"aXXXXXXaaaa",
"aXXXaXXa...",
"aXXaaXXa...",
"aXa..aXXa..",
"aa...aXXa..",
"a.....aXXa.",
"......aXXa.",
".......aXXa",
".......aXXa",
"........aa."};

static const char * const xpmPixmapData3[] = {
"20 20 2 1",
"       c #000000",
".      c #C32D2D",
"          ..........",
"            ........",
"             .......",
"              ......",
"                ....",
"                  ..",
"                   .",
"                    ",
"                    ",
".                   ",
"...                 ",
".....               ",
"......              ",
".......             ",
".........           ",
"...........         ",
"...........         ",
"............        ",
"............        ",
".............       "};

class tst_Cmptest: public QObject
{
    Q_OBJECT

public:
    enum class MyClassEnum { MyClassEnumValue1, MyClassEnumValue2 };
    Q_ENUM(MyClassEnum)

private slots:
    void compare_unregistered_enums();
    void compare_registered_enums();
    void compare_class_enums();
    void test_windowflags_data();
    void test_windowflags();
    void test_unregistered_flags_data();
    void test_unregistered_flags();
    void compare_boolfuncs();
    void compare_to_nullptr();
    void compare_pointerfuncs();
    void compare_tostring();
    void compare_tostring_data();
    void compareQStringLists();
    void compareQStringLists_data();
    void compareQListInt();
    void compareQListDouble();
#ifdef QT_GUI_LIB
    void compareQColor_data();
    void compareQColor();
    void compareQPixmaps();
    void compareQPixmaps_data();
    void compareQImages();
    void compareQImages_data();
    void compareQRegion_data();
    void compareQRegion();
    void compareQVector2D();
    void compareQVector3D();
    void compareQVector4D();
#endif
    void verify();
    void verify2();
    void tryVerify();
    void tryVerify2();
    void verifyExplicitOperatorBool();
};

enum MyUnregisteredEnum { MyUnregisteredEnumValue1, MyUnregisteredEnumValue2 };

void tst_Cmptest::compare_unregistered_enums()
{
    QCOMPARE(MyUnregisteredEnumValue1, MyUnregisteredEnumValue1);
    QCOMPARE(MyUnregisteredEnumValue1, MyUnregisteredEnumValue2);
}

void tst_Cmptest::compare_registered_enums()
{
    // use an enum that doesn't start at 0
    QCOMPARE(Qt::Monday, Qt::Monday);
    QCOMPARE(Qt::Monday, Qt::Sunday);
}

void tst_Cmptest::compare_class_enums()
{
    QCOMPARE(MyClassEnum::MyClassEnumValue1, MyClassEnum::MyClassEnumValue1);
    QCOMPARE(MyClassEnum::MyClassEnumValue1, MyClassEnum::MyClassEnumValue2);
}

void tst_Cmptest::test_windowflags_data()
{
    QTest::addColumn<Qt::WindowFlags>("actualWindowFlags");
    QTest::addColumn<Qt::WindowFlags>("expectedWindowFlags");

    const Qt::WindowFlags windowFlags = Qt::Window
        | Qt::WindowSystemMenuHint | Qt::WindowStaysOnBottomHint;
    QTest::newRow("pass")
        << windowFlags
        << windowFlags;
    QTest::newRow("fail1")
        << windowFlags
        << (windowFlags | Qt::FramelessWindowHint);
    QTest::newRow("fail2")
        << Qt::WindowFlags(Qt::Window)
        << Qt::WindowFlags(Qt::Window | Qt::FramelessWindowHint);
}

void tst_Cmptest::test_windowflags()
{
    QFETCH(Qt::WindowFlags, actualWindowFlags);
    QFETCH(Qt::WindowFlags, expectedWindowFlags);
    QCOMPARE(actualWindowFlags, expectedWindowFlags);
}

enum UnregisteredEnum {
    UnregisteredEnumValue1 = 0x1,
    UnregisteredEnumValue2 = 0x2,
    UnregisteredEnumValue3 = 0x4
};

typedef QFlags<UnregisteredEnum> UnregisteredFlags;

Q_DECLARE_METATYPE(UnregisteredFlags);

void tst_Cmptest::test_unregistered_flags_data()
{
    QTest::addColumn<UnregisteredFlags>("actualFlags");
    QTest::addColumn<UnregisteredFlags>("expectedFlags");

    QTest::newRow("pass")
        << UnregisteredFlags(UnregisteredEnumValue1)
        << UnregisteredFlags(UnregisteredEnumValue1);
    QTest::newRow("fail1")
        << UnregisteredFlags(UnregisteredEnumValue1 | UnregisteredEnumValue2)
        << UnregisteredFlags(UnregisteredEnumValue1 | UnregisteredEnumValue3);
    QTest::newRow("fail2")
        << UnregisteredFlags(UnregisteredEnumValue1)
        << UnregisteredFlags(UnregisteredEnumValue1 | UnregisteredEnumValue3);
}

void tst_Cmptest::test_unregistered_flags()
{
    QFETCH(UnregisteredFlags, actualFlags);
    QFETCH(UnregisteredFlags, expectedFlags);
    QCOMPARE(actualFlags, expectedFlags);
}

static bool boolfunc() { return true; }
static bool boolfunc2() { return true; }

void tst_Cmptest::compare_boolfuncs()
{
    QCOMPARE(boolfunc(), boolfunc());
    QCOMPARE(boolfunc(), boolfunc2());
    QCOMPARE(!boolfunc(), !boolfunc2());
    QCOMPARE(boolfunc(), true);
    QCOMPARE(!boolfunc(), false);
}

namespace {
template <typename T>
T *null() noexcept { return nullptr; }
}

void tst_Cmptest::compare_to_nullptr()
{
    QCOMPARE(null<int>(), nullptr);
    QCOMPARE(null<const int>(), nullptr);
    QCOMPARE(null<volatile int>(), nullptr);
    QCOMPARE(null<const volatile int>(), nullptr);

    QCOMPARE(nullptr, null<int>());
    QCOMPARE(nullptr, null<const int>());
    QCOMPARE(nullptr, null<volatile int>());
    QCOMPARE(nullptr, null<const volatile int>());
}

static int i = 0;

static int *intptr() { return &i; }

void tst_Cmptest::compare_pointerfuncs()
{
    QCOMPARE(intptr(), intptr());
    QCOMPARE(&i, &i);
    QCOMPARE(intptr(), &i);
    QCOMPARE(&i, intptr());
}


struct PhonyClass
{
    int i;
};

void tst_Cmptest::compare_tostring_data()
{
    QTest::addColumn<QVariant>("actual");
    QTest::addColumn<QVariant>("expected");

    QTest::newRow("int, string")
        << QVariant::fromValue(123)
        << QVariant::fromValue(QString("hi"))
    ;

    QTest::newRow("both invalid")
        << QVariant()
        << QVariant()
    ;

    QTest::newRow("null hash, invalid")
        << QVariant(QVariant::Hash)
        << QVariant()
    ;

    QTest::newRow("string, null user type")
        << QVariant::fromValue(QString::fromLatin1("A simple string"))
        << QVariant(QVariant::Type(qRegisterMetaType<PhonyClass>("PhonyClass")))
    ;

    PhonyClass fake1 = {1};
    PhonyClass fake2 = {2};
    QTest::newRow("both non-null user type")
        << QVariant(qRegisterMetaType<PhonyClass>("PhonyClass"), (const void*)&fake1)
        << QVariant(qRegisterMetaType<PhonyClass>("PhonyClass"), (const void*)&fake2)
    ;
}

void tst_Cmptest::compare_tostring()
{
    QFETCH(QVariant, actual);
    QFETCH(QVariant, expected);

    QCOMPARE(actual, expected);
}

void tst_Cmptest::compareQStringLists_data()
{
    QTest::addColumn<QStringList>("opA");
    QTest::addColumn<QStringList>("opB");

    {
        QStringList opA;
        QStringList opB(opA);

        QTest::newRow("empty lists") << opA << opB;
    }

    {
        QStringList opA;
        opA.append(QLatin1String("string1"));
        opA.append(QLatin1String("string2"));
        opA.append(QLatin1String("string3"));
        opA.append(QLatin1String("string4"));

        QStringList opB(opA);

        QTest::newRow("equal lists") << opA << opB;
    }

    {
        QStringList opA;
        opA.append(QLatin1String("string1"));
        opA.append(QLatin1String("string2"));

        QStringList opB(opA);
        opA.append(QLatin1String("string3"));
        opB.append(QLatin1String("DIFFERS"));

        QTest::newRow("last item different") << opA << opB;
    }

    {
        QStringList opA;
        opA.append(QLatin1String("string1"));
        opA.append(QLatin1String("string2"));

        QStringList opB(opA);
        opA.append(QLatin1String("string3"));
        opA.append(QLatin1String("string4"));

        opB.append(QLatin1String("DIFFERS"));
        opB.append(QLatin1String("string4"));

        QTest::newRow("second-last item different") << opA << opB;
    }

    {
        QStringList opA;
        opA.append(QLatin1String("string1"));
        opA.append(QLatin1String("string2"));

        QStringList opB;
        opB.append(QLatin1String("string1"));

        QTest::newRow("prefix") << opA << opB;
    }

    {
        QStringList opA;
        opA.append(QLatin1String("openInNewWindow"));
        opA.append(QLatin1String("openInNewTab"));
        opA.append(QLatin1String("separator"));
        opA.append(QLatin1String("bookmark_add"));
        opA.append(QLatin1String("savelinkas"));
        opA.append(QLatin1String("copylinklocation"));
        opA.append(QLatin1String("separator"));
        opA.append(QLatin1String("openWith_submenu"));
        opA.append(QLatin1String("preview1"));
        opA.append(QLatin1String("actions_submenu"));
        opA.append(QLatin1String("separator"));
        opA.append(QLatin1String("viewDocumentSource"));

        QStringList opB;
        opB.append(QLatin1String("viewDocumentSource"));

        QTest::newRow("short list second") << opA << opB;

        QTest::newRow("short list first") << opB << opA;
    }
}

void tst_Cmptest::compareQStringLists()
{
    QFETCH(QStringList, opA);
    QFETCH(QStringList, opB);

    QCOMPARE(opA, opB);
}

void tst_Cmptest::compareQListInt()
{
    QList<int> int1; int1 << 1 << 2 << 3;
    QList<int> int2; int2 << 1 << 2 << 4;
    QCOMPARE(int1, int2);
}

void tst_Cmptest::compareQListDouble()
{
    QList<double> double1; double1 << 1.5 << 2 << 3;
    QList<double> double2; double2 << 1 << 2 << 4;
    QCOMPARE(double1, double2);
}

#ifdef QT_GUI_LIB
void tst_Cmptest::compareQColor_data()
{
    QTest::addColumn<QColor>("colorA");
    QTest::addColumn<QColor>("colorB");

    QTest::newRow("Qt::yellow vs \"yellow\"") << QColor(Qt::yellow) << QColor(QStringLiteral("yellow"));
    QTest::newRow("Qt::yellow vs Qt::green") << QColor(Qt::yellow) << QColor(Qt::green);
    QTest::newRow("0x88ff0000 vs 0xffff0000") << QColor::fromRgba(0x88ff0000) << QColor::fromRgba(0xffff0000);
}

void tst_Cmptest::compareQColor()
{
    QFETCH(QColor, colorA);
    QFETCH(QColor, colorB);

    QCOMPARE(colorA, colorB);
}

void tst_Cmptest::compareQPixmaps_data()
{
    QTest::addColumn<QPixmap>("opA");
    QTest::addColumn<QPixmap>("opB");

    const QPixmap pixmap1(xpmPixmapData1);
    const QPixmap pixmap2(xpmPixmapData2);
    const QPixmap pixmap3(xpmPixmapData3);
    QPixmap pixmapWrongDpr = pixmap1.scaled(2, 2);
    pixmapWrongDpr.setDevicePixelRatio(2);

    QTest::newRow("both null") << QPixmap() << QPixmap();
    QTest::newRow("one null") << QPixmap() << pixmap1;
    QTest::newRow("other null") << pixmap1 << QPixmap();
    QTest::newRow("equal") << pixmap1 << pixmap1;
    QTest::newRow("different size") << pixmap1 << pixmap3;
    QTest::newRow("different pixels") << pixmap1 << pixmap2;
    QTest::newRow("different dpr") << pixmap1 << pixmapWrongDpr;
}

void tst_Cmptest::compareQPixmaps()
{
    QFETCH(QPixmap, opA);
    QFETCH(QPixmap, opB);

    QCOMPARE(opA, opB);
}

void tst_Cmptest::compareQImages_data()
{
    QTest::addColumn<QImage>("opA");
    QTest::addColumn<QImage>("opB");

    const QImage image1(QPixmap(xpmPixmapData1).toImage());
    const QImage image2(QPixmap(xpmPixmapData2).toImage());
    const QImage image1Indexed = image1.convertToFormat(QImage::Format_Indexed8);
    const QImage image3(QPixmap(xpmPixmapData3).toImage());
    QImage imageWrongDpr = image1.scaled(2, 2);
    imageWrongDpr.setDevicePixelRatio(2);

    QTest::newRow("both null") << QImage() << QImage();
    QTest::newRow("one null") << QImage() << image1;
    QTest::newRow("other null") << image1 << QImage();
    QTest::newRow("equal") << image1 << image1;
    QTest::newRow("different size") << image1 << image3;
    QTest::newRow("different format") << image1 << image1Indexed;
    QTest::newRow("different pixels") << image1 << image2;
    QTest::newRow("different dpr") << image1 << imageWrongDpr;
}

void tst_Cmptest::compareQImages()
{
    QFETCH(QImage, opA);
    QFETCH(QImage, opB);

    QCOMPARE(opA, opB);
}

void tst_Cmptest::compareQRegion_data()
{
    QTest::addColumn<QRegion>("rA");
    QTest::addColumn<QRegion>("rB");
    const QRect rect1(QPoint(10, 10), QSize(200, 50));
    const QRegion region1(rect1);
    QRegion listRegion2;
    const QVector<QRect> list2 = QVector<QRect>() << QRect(QPoint(100, 200), QSize(50, 200)) << rect1;
    listRegion2.setRects(list2.constData(), list2.size());
    QTest::newRow("equal-empty") << QRegion() << QRegion();
    QTest::newRow("1-empty") << region1 << QRegion();
    QTest::newRow("equal") << region1 << region1;
    QTest::newRow("different lists") << region1 << listRegion2;
}

void tst_Cmptest::compareQRegion()
{
    QFETCH(QRegion, rA);
    QFETCH(QRegion, rB);

    QCOMPARE(rA, rB);
}

void tst_Cmptest::compareQVector2D()
{
    QVector2D v2a{1, 2};
    QVector2D v2b = v2a;
    QCOMPARE(v2a, v2b);
    v2b.setY(3);
    QCOMPARE(v2a, v2b);
}

void tst_Cmptest::compareQVector3D()
{
    QVector3D v3a{1, 2, 3};
    QVector3D v3b = v3a;
    QCOMPARE(v3a, v3b);
    v3b.setY(3);
    QCOMPARE(v3a, v3b);
}

void tst_Cmptest::compareQVector4D()
{
    QVector4D v4a{1, 2, 3, 4};
    QVector4D v4b = v4a;
    QCOMPARE(v4a, v4b);
    v4b.setY(3);
    QCOMPARE(v4a, v4b);
}
#endif // QT_GUI_LIB

static int opaqueFunc()
{
    return 42;
}

void tst_Cmptest::verify()
{
    QVERIFY(opaqueFunc() > 2);
    QVERIFY(opaqueFunc() < 2);
}

void tst_Cmptest::verify2()
{
    QVERIFY2(opaqueFunc() > 2, QByteArray::number(opaqueFunc()).constData());
    QVERIFY2(opaqueFunc() < 2, QByteArray::number(opaqueFunc()).constData());
}

void tst_Cmptest::tryVerify()
{
    QTRY_VERIFY(opaqueFunc() > 2);
    QTRY_VERIFY_WITH_TIMEOUT(opaqueFunc() < 2, 1);
}

void tst_Cmptest::tryVerify2()
{
    QTRY_VERIFY2(opaqueFunc() > 2, QByteArray::number(opaqueFunc()).constData());
    QTRY_VERIFY2_WITH_TIMEOUT(opaqueFunc() < 2, QByteArray::number(opaqueFunc()).constData(), 1);
}

void tst_Cmptest::verifyExplicitOperatorBool()
{
    struct ExplicitOperatorBool {
        int m_i;
        explicit ExplicitOperatorBool(int i) : m_i(i) {}
        explicit operator bool() const { return m_i > 0; }
        bool operator !() const { return !bool(*this); }
    };

    ExplicitOperatorBool val1(42);
    QVERIFY(val1);

    ExplicitOperatorBool val2(-273);
    QVERIFY(!val2);
}

QTEST_MAIN(tst_Cmptest)
#include "tst_cmptest.moc"