/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <qicon.h>

#if defined(Q_OS_SYMBIAN)

#define SRCDIR "."

#endif

#include <qiconengine.h>

Q_DECLARE_METATYPE(QSize)

//TESTED_CLASS=

//TESTED_FILES=

class tst_QIcon : public QObject

{

    Q_OBJECT

public:

    tst_QIcon();

private slots:

    void init();

    void cleanup();

    void actualSize_data(); // test with 1 pixmap

    void actualSize();

    void actualSize2_data(); // test with 2 pixmaps with different aspect ratio

    void actualSize2();

    void svgActualSize();

    void isNull();

    void bestMatch();

    void cacheKey();

    void detach();

    void svg();

    void addFile();

    void availableSizes();

    void name();

    void streamAvailableSizes_data();

    void streamAvailableSizes();

    void fromTheme();

    void task184901_badCache();

    void task223279_inconsistentAddFile();

    void task239461_custom_iconengine_crash();

private:

    QString oldCurrentDir;

    const static QIcon staticIcon;

};

// Creating an icon statically should not cause a crash. 

// But we do not officially support this. See QTBUG-8666

const QIcon tst_QIcon::staticIcon = QIcon::fromTheme("edit-find");

void tst_QIcon::init()

{

    QString srcdir(QLatin1String(SRCDIR));

    if (!srcdir.isEmpty()) {

        oldCurrentDir = QDir::current().absolutePath();

        QDir::setCurrent(srcdir);

    }

}

void tst_QIcon::cleanup()

{

    if (!oldCurrentDir.isEmpty()) {

        QDir::setCurrent(oldCurrentDir);

    }

}

tst_QIcon::tst_QIcon()

{

}

void tst_QIcon::actualSize_data()

{

    QTest::addColumn<QString>("source");

    QTest::addColumn<QSize>("argument");

    QTest::addColumn<QSize>("result");

    // square image

    QTest::newRow("resource0") << ":/image.png" << QSize(128, 128) << QSize(128, 128);

    QTest::newRow("resource1") << ":/image.png" << QSize( 64,  64) << QSize( 64,  64);

    QTest::newRow("resource2") << ":/image.png" << QSize( 32,  64) << QSize( 32,  32);

    QTest::newRow("resource3") << ":/image.png" << QSize( 16,  64) << QSize( 16,  16);

    QTest::newRow("resource4") << ":/image.png" << QSize( 16,  128) << QSize( 16,  16);

    QTest::newRow("resource5") << ":/image.png" << QSize( 128,  16) << QSize( 16,  16);

    QTest::newRow("resource6") << ":/image.png" << QSize( 150,  150) << QSize( 128,  128);

    // rect image

    QTest::newRow("resource7") << ":/rect.png" << QSize( 20,  40) << QSize( 20,  40);

    QTest::newRow("resource8") << ":/rect.png" << QSize( 10,  20) << QSize( 10,  20);

    QTest::newRow("resource9") << ":/rect.png" << QSize( 15,  50) << QSize( 15,  30);

    QTest::newRow("resource10") << ":/rect.png" << QSize( 25,  50) << QSize( 20,  40);

    const QString prefix = QLatin1String(SRCDIR) + QLatin1String("/");

    QTest::newRow("external0") << prefix + "image.png" << QSize(128, 128) << QSize(128, 128);

    QTest::newRow("external1") << prefix + "image.png" << QSize( 64,  64) << QSize( 64,  64);

    QTest::newRow("external2") << prefix + "image.png" << QSize( 32,  64) << QSize( 32,  32);

    QTest::newRow("external3") << prefix + "image.png" << QSize( 16,  64) << QSize( 16,  16);

    QTest::newRow("external4") << prefix + "image.png" << QSize( 16,  128) << QSize( 16,  16);

    QTest::newRow("external5") << prefix + "image.png" << QSize( 128,  16) << QSize( 16,  16);

    QTest::newRow("external6") << prefix + "image.png" << QSize( 150,  150) << QSize( 128,  128);

    // rect image

    QTest::newRow("external7") << ":/rect.png" << QSize( 20,  40) << QSize( 20,  40);

    QTest::newRow("external8") << ":/rect.png" << QSize( 10,  20) << QSize( 10,  20);

    QTest::newRow("external9") << ":/rect.png" << QSize( 15,  50) << QSize( 15,  30);

    QTest::newRow("external10") << ":/rect.png" << QSize( 25,  50) << QSize( 20,  40);

}

void tst_QIcon::actualSize()

{

    QFETCH(QString, source);

    QFETCH(QSize, argument);

    QFETCH(QSize, result);

    {

        QPixmap pixmap(source);

        QIcon icon(pixmap);

        QCOMPARE(icon.actualSize(argument), result);

        QCOMPARE(icon.pixmap(argument).size(), result);

    }

    {

        QIcon icon(source);

        QCOMPARE(icon.actualSize(argument), result);

        QCOMPARE(icon.pixmap(argument).size(), result);

    }

}

void tst_QIcon::actualSize2_data()

{

    QTest::addColumn<QSize>("argument");

    QTest::addColumn<QSize>("result");

    // two images - 128x128 and 20x40. Let the games begin

    QTest::newRow("trivial1") << QSize( 128,  128) << QSize( 128,  128);

    QTest::newRow("trivial2") << QSize( 20,  40) << QSize( 20,  40);

    // QIcon chooses the one with the smallest area to choose the pixmap

    QTest::newRow("best1") << QSize( 100,  100) << QSize( 100,  100);

    QTest::newRow("best2") << QSize( 20,  20) << QSize( 10,  20);

    QTest::newRow("best3") << QSize( 15,  30) << QSize( 15,  30);

    QTest::newRow("best4") << QSize( 5,  5) << QSize( 2,  5);

    QTest::newRow("best5") << QSize( 10,  15) << QSize( 7,  15);

}

void tst_QIcon::actualSize2()

{

    QIcon icon;

    const QString prefix = QLatin1String(SRCDIR) + QLatin1String("/");

    icon.addPixmap(QPixmap(prefix + "image.png"));

    icon.addPixmap(QPixmap(prefix + "rect.png"));

    QFETCH(QSize, argument);

    QFETCH(QSize, result);

    QCOMPARE(icon.actualSize(argument), result);

    QCOMPARE(icon.pixmap(argument).size(), result);

}

void tst_QIcon::svgActualSize()

{

    const QString prefix = QLatin1String(SRCDIR) + QLatin1String("/");

    QIcon icon(prefix + "rect.svg");

    QCOMPARE(icon.actualSize(QSize(16, 16)), QSize(16, 2));

    QCOMPARE(icon.pixmap(QSize(16, 16)).size(), QSize(16, 2));

    QPixmap p(16, 16);

    p.fill(Qt::cyan);

    icon.addPixmap(p);

    QCOMPARE(icon.actualSize(QSize(16, 16)), QSize(16, 16));

    QCOMPARE(icon.pixmap(QSize(16, 16)).size(), QSize(16, 16));

    QCOMPARE(icon.actualSize(QSize(16, 14)), QSize(16, 2));

    QCOMPARE(icon.pixmap(QSize(16, 14)).size(), QSize(16, 2));

}

void tst_QIcon::isNull() {

    // test default constructor

    QIcon defaultConstructor;

    QVERIFY(defaultConstructor.isNull());

    // test copy constructor

    QVERIFY(QIcon(defaultConstructor).isNull());

    // test pixmap constructor

    QPixmap nullPixmap;

    QVERIFY(QIcon(nullPixmap).isNull());

    // test string constructor with empty string

    QIcon iconEmptyString = QIcon(QString());

    QVERIFY(iconEmptyString.isNull());

    QVERIFY(!iconEmptyString.actualSize(QSize(32, 32)).isValid());;

    // test string constructor with non-existing file

    QIcon iconNoFile = QIcon("imagedoesnotexist");

    QVERIFY(!iconNoFile.isNull());

    QVERIFY(!iconNoFile.actualSize(QSize(32, 32)).isValid());

    // test string constructor with non-existing file with suffix

    QIcon iconNoFileSuffix = QIcon("imagedoesnotexist.png");

    QVERIFY(!iconNoFileSuffix.isNull());

    QVERIFY(!iconNoFileSuffix.actualSize(QSize(32, 32)).isValid());

    const QString prefix = QLatin1String(SRCDIR) + QLatin1String("/");

    // test string constructor with existing file but unsupported format

    QIcon iconUnsupportedFormat = QIcon(prefix + "tst_qicon.cpp");

    QVERIFY(!iconUnsupportedFormat.isNull());

    QVERIFY(!iconUnsupportedFormat.actualSize(QSize(32, 32)).isValid());

    // test string constructor with existing file and supported format

    QIcon iconSupportedFormat = QIcon(prefix + "image.png");

    QVERIFY(!iconSupportedFormat.isNull());

    QVERIFY(iconSupportedFormat.actualSize(QSize(32, 32)).isValid());

}

void tst_QIcon::bestMatch()

{

    QPixmap p1(1, 1);

    QPixmap p2(2, 2);

    QPixmap p3(3, 3);

    QPixmap p4(4, 4);

    QPixmap p5(5, 5);

    QPixmap p6(6, 6);

    QPixmap p7(7, 7);

    QPixmap p8(8, 8);

    p1.fill(Qt::black);

    p2.fill(Qt::black);

    p3.fill(Qt::black);

    p4.fill(Qt::black);

    p5.fill(Qt::black);

    p6.fill(Qt::black);

    p7.fill(Qt::black);

    p8.fill(Qt::black);

    for (int i = 0; i < 4; ++i) {

        for (int j = 0; j < 2; ++j) {

            QIcon::State state = (j == 0) ? QIcon::On : QIcon::Off;

            QIcon::State oppositeState = (state == QIcon::On) ? QIcon::Off

                                                              : QIcon::On;

            QIcon::Mode mode;

            QIcon::Mode oppositeMode;

            QIcon icon;

            switch (i) {

            case 0:

            default:

                mode = QIcon::Normal;

                oppositeMode = QIcon::Active;

                break;

            case 1:

                mode = QIcon::Active;

                oppositeMode = QIcon::Normal;

                break;

            case 2:

                mode = QIcon::Disabled;

                oppositeMode = QIcon::Selected;

                break;

            case 3:

                mode = QIcon::Selected;

                oppositeMode = QIcon::Disabled;

            }

            /*

                The test mirrors the code in

                QPixmapIconEngine::bestMatch(), to make sure that

                nobody breaks QPixmapIconEngine by mistake. Before

                you change this test or the code that it tests,

                please talk to the maintainer if possible.

            */

            if (mode == QIcon::Disabled || mode == QIcon::Selected) {

                icon.addPixmap(p1, oppositeMode, oppositeState);

                QVERIFY(icon.pixmap(100, mode, state).size() == p1.size());

                icon.addPixmap(p2, oppositeMode, state);

                QVERIFY(icon.pixmap(100, mode, state).size() == p2.size());

                icon.addPixmap(p3, QIcon::Active, oppositeState);

                QVERIFY(icon.pixmap(100, mode, state).size() == p3.size());

                icon.addPixmap(p4, QIcon::Normal, oppositeState);

                QVERIFY(icon.pixmap(100, mode, state).size() == p4.size());

                icon.addPixmap(p5, mode, oppositeState);

                QVERIFY(icon.pixmap(100, mode, state).size() == p5.size());

                icon.addPixmap(p6, QIcon::Active, state);

                QVERIFY(icon.pixmap(100, mode, state).size() == p6.size());

                icon.addPixmap(p7, QIcon::Normal, state);

                QVERIFY(icon.pixmap(100, mode, state).size() == p7.size());

                icon.addPixmap(p8, mode, state);

                QVERIFY(icon.pixmap(100, mode, state).size() == p8.size());

            } else {

                icon.addPixmap(p1, QIcon::Selected, oppositeState);

                QVERIFY(icon.pixmap(100, mode, state).size() == p1.size());

                icon.addPixmap(p2, QIcon::Disabled, oppositeState);

                QVERIFY(icon.pixmap(100, mode, state).size() == p2.size());

                icon.addPixmap(p3, QIcon::Selected, state);

                QVERIFY(icon.pixmap(100, mode, state).size() == p3.size());

                icon.addPixmap(p4, QIcon::Disabled, state);

                QVERIFY(icon.pixmap(100, mode, state).size() == p4.size());

                icon.addPixmap(p5, oppositeMode, oppositeState);

                QVERIFY(icon.pixmap(100, mode, state).size() == p5.size());

                icon.addPixmap(p6, mode, oppositeState);

                QVERIFY(icon.pixmap(100, mode, state).size() == p6.size());

                icon.addPixmap(p7, oppositeMode, state);

                QVERIFY(icon.pixmap(100, mode, state).size() == p7.size());

                icon.addPixmap(p8, mode, state);

                QVERIFY(icon.pixmap(100, mode, state).size() == p8.size());

            }

        }

    }

}

void tst_QIcon::cacheKey()

{

    QIcon icon1("image.png");

    qint64 icon1_key = icon1.cacheKey();

    QIcon icon2 = icon1;

    QVERIFY(icon2.cacheKey() == icon1.cacheKey());

    icon2.detach();

    QVERIFY(icon2.cacheKey() != icon1.cacheKey());

    QVERIFY(icon1.cacheKey() == icon1_key);

}

void tst_QIcon::detach()

{

    QImage img(32, 32, QImage::Format_ARGB32_Premultiplied);

    img.fill(0xffff0000);

    QIcon icon1(QPixmap::fromImage(img));

    QIcon icon2 = icon1;

    icon2.addFile("image.png", QSize(64, 64));

    QImage img1 = icon1.pixmap(64, 64).toImage();

    QImage img2 = icon2.pixmap(64, 64).toImage();

    QVERIFY(img1 != img2);

    img1 = icon1.pixmap(32, 32).toImage();

    img2 = icon2.pixmap(32, 32).toImage();

    QVERIFY(img1 == img2);

}

void tst_QIcon::svg()

{

    QIcon icon1("heart.svg");

    QVERIFY(!icon1.pixmap(32).isNull());

    QImage img1 = icon1.pixmap(32).toImage();

    QVERIFY(!icon1.pixmap(32, QIcon::Disabled).isNull());

    QImage img2 = icon1.pixmap(32, QIcon::Disabled).toImage();

    icon1.addFile("trash.svg", QSize(), QIcon::Disabled);

    QVERIFY(!icon1.pixmap(32, QIcon::Disabled).isNull());

    QImage img3 = icon1.pixmap(32, QIcon::Disabled).toImage();

    QVERIFY(img3 != img2);

    QVERIFY(img3 != img1);

    QPixmap pm("image.png");

    icon1.addPixmap(pm, QIcon::Normal, QIcon::On);

    QVERIFY(!icon1.pixmap(128, QIcon::Normal, QIcon::On).isNull());

    QImage img4 = icon1.pixmap(128, QIcon::Normal, QIcon::On).toImage();

    QVERIFY(img4 != img3);

    QVERIFY(img4 != img2);

    QVERIFY(img4 != img1);

    QIcon icon2;

    icon2.addFile("heart.svg");

    QVERIFY(icon2.pixmap(57).toImage() == icon1.pixmap(57).toImage());

    QIcon icon3("trash.svg");

    icon3.addFile("heart.svg");

    QVERIFY(icon3.pixmap(57).toImage() == icon1.pixmap(57).toImage());

    QIcon icon4("heart.svg");

    icon4.addFile("image.png", QSize(), QIcon::Active);

    QVERIFY(!icon4.pixmap(32).isNull());

    QVERIFY(!icon4.pixmap(32, QIcon::Active).isNull());

    QVERIFY(icon4.pixmap(32).toImage() == img1);

    QIcon pmIcon(pm);

    QVERIFY(icon4.pixmap(pm.size(), QIcon::Active).toImage() == pmIcon.pixmap(pm.size(), QIcon::Active).toImage());

#ifndef QT_NO_COMPRESS

    QIcon icon5("heart.svgz");

    QVERIFY(!icon5.pixmap(32).isNull());

#endif

}

void tst_QIcon::addFile()

{

    QIcon icon;

    icon.addFile(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-open-16.png"));

    icon.addFile(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-open-32.png"));

    icon.addFile(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-open-128.png"));

    icon.addFile(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-save-16.png"), QSize(), QIcon::Selected);

    icon.addFile(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-save-32.png"), QSize(), QIcon::Selected);

    icon.addFile(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-save-128.png"), QSize(), QIcon::Selected);

#ifndef Q_OS_WINCE

    QVERIFY(icon.pixmap(16, QIcon::Normal).toImage() ==

            QPixmap(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-open-16.png")).toImage());

    QVERIFY(icon.pixmap(32, QIcon::Normal).toImage() ==

            QPixmap(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-open-32.png")).toImage());

    QVERIFY(icon.pixmap(128, QIcon::Normal).toImage() ==

            QPixmap(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-open-128.png")).toImage());

    QVERIFY(icon.pixmap(16, QIcon::Selected).toImage() ==

            QPixmap(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-save-16.png")).toImage());

    QVERIFY(icon.pixmap(32, QIcon::Selected).toImage() ==

            QPixmap(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-save-32.png")).toImage());

    QVERIFY(icon.pixmap(128, QIcon::Selected).toImage() ==

            QPixmap(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-save-128.png")).toImage());

#else

    // WinCE only includes the 16x16 images for size reasons

    QVERIFY(icon.pixmap(16, QIcon::Normal).toImage() ==

            QPixmap(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-open-16.png")).toImage());

    QVERIFY(icon.pixmap(16, QIcon::Selected).toImage() ==

            QPixmap(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-save-16.png")).toImage());

#endif

}

static bool sizeLess(const QSize &a, const QSize &b)

{

    return a.width() < b.width();

}

void tst_QIcon::availableSizes()

{

    {

        QIcon icon;

        icon.addFile("image.png", QSize(32,32));

        icon.addFile("image.png", QSize(64,64));

        icon.addFile("image.png", QSize(128,128));

        icon.addFile("image.png", QSize(256,256), QIcon::Disabled);

        icon.addFile("image.png", QSize(16,16), QIcon::Normal, QIcon::On);

        QList<QSize> availableSizes = icon.availableSizes();

        QCOMPARE(availableSizes.size(), 3);

        qSort(availableSizes.begin(), availableSizes.end(), sizeLess);

        QCOMPARE(availableSizes.at(0), QSize(32,32));

        QCOMPARE(availableSizes.at(1), QSize(64,64));

        QCOMPARE(availableSizes.at(2), QSize(128,128));

        availableSizes = icon.availableSizes(QIcon::Disabled);

        QCOMPARE(availableSizes.size(), 1);

        QCOMPARE(availableSizes.at(0), QSize(256,256));

        availableSizes = icon.availableSizes(QIcon::Normal, QIcon::On);

        QCOMPARE(availableSizes.size(), 1);

        QCOMPARE(availableSizes.at(0), QSize(16,16));

    }

    {

        // checks that there are no availableSizes for scalable images.

        QIcon icon("heart.svg");

        QList<QSize> availableSizes = icon.availableSizes();

        QVERIFY(availableSizes.isEmpty());

    }

    {

        // even if an a scalable image contain added pixmaps,

        // availableSizes still should be empty.

        QIcon icon("heart.svg");

        icon.addFile("image.png", QSize(32,32));

        QList<QSize> availableSizes = icon.availableSizes();

        QVERIFY(availableSizes.isEmpty());

    }

    {

        // we try to load an icon from resources

        QIcon icon(QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-open-16.png"));

        QList<QSize> availableSizes = icon.availableSizes();