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

**

** 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>

#if QT_VERSION < 0x040200

QTEST_NOOP_MAIN

#else

#include <qeasingcurve.h>

//TESTED_CLASS=

//TESTED_FILES=

class tst_QEasingCurve : public QObject {

  Q_OBJECT

public:

    tst_QEasingCurve();

    virtual ~tst_QEasingCurve();

public Q_SLOTS:

    void init();

    void cleanup();

private slots:

    void type();

    void propertyDefaults();

    void valueForProgress_data();

    void valueForProgress();

    void setCustomType();

    void operators();

protected:

};

tst_QEasingCurve::tst_QEasingCurve()

{

}

tst_QEasingCurve::~tst_QEasingCurve()

{

}

void tst_QEasingCurve::init()

{

}

void tst_QEasingCurve::cleanup()

{

}

#include <qdebug.h>

void tst_QEasingCurve::type()

{

    {

    QEasingCurve curve(QEasingCurve::Linear);

    QCOMPARE(curve.period(), 0.3);

    QCOMPARE(curve.amplitude(), 1.0);

    curve.setPeriod(5);

    curve.setAmplitude(3);

    QCOMPARE(curve.period(), 5.0);

    QCOMPARE(curve.amplitude(), 3.0);

    curve.setType(QEasingCurve::InElastic);

    QCOMPARE(curve.period(), 5.0);

    QCOMPARE(curve.amplitude(), 3.0);

    }

    {

    QEasingCurve curve(QEasingCurve::InElastic);

    QCOMPARE(curve.period(), 0.3);

    QCOMPARE(curve.amplitude(), 1.0);

    curve.setAmplitude(2);

    QCOMPARE(curve.type(), QEasingCurve::InElastic);

    curve.setType(QEasingCurve::Linear);

    }

    {

    // check bounaries

    QEasingCurve curve(QEasingCurve::InCubic);

    QTest::ignoreMessage(QtWarningMsg, "QEasingCurve: Invalid curve type 9999");

    curve.setType((QEasingCurve::Type)9999);

    QCOMPARE(curve.type(), QEasingCurve::InCubic);

    QTest::ignoreMessage(QtWarningMsg, "QEasingCurve: Invalid curve type -9999");

    curve.setType((QEasingCurve::Type)-9999);

    QCOMPARE(curve.type(), QEasingCurve::InCubic);

    QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QEasingCurve: Invalid curve type %1")

                        .arg(QEasingCurve::NCurveTypes).toLatin1().constData());

    curve.setType(QEasingCurve::NCurveTypes);

    QCOMPARE(curve.type(), QEasingCurve::InCubic);

    QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QEasingCurve: Invalid curve type %1")

                        .arg(QEasingCurve::Custom).toLatin1().constData());

    curve.setType(QEasingCurve::Custom);

    QCOMPARE(curve.type(), QEasingCurve::InCubic);

    QTest::ignoreMessage(QtWarningMsg, QString::fromAscii("QEasingCurve: Invalid curve type %1")

                        .arg(-1).toLatin1().constData());

    curve.setType((QEasingCurve::Type)-1);

    QCOMPARE(curve.type(), QEasingCurve::InCubic);

    curve.setType(QEasingCurve::Linear);

    QCOMPARE(curve.type(), QEasingCurve::Linear);

    curve.setType(QEasingCurve::CosineCurve);

    QCOMPARE(curve.type(), QEasingCurve::CosineCurve);

    }

}

void tst_QEasingCurve::propertyDefaults()

{

    {

    // checks if the defaults are correct, but also demonstrates a weakness with the API.

    QEasingCurve curve(QEasingCurve::InElastic);

    QCOMPARE(curve.period(), 0.3);

    QCOMPARE(curve.amplitude(), 1.0);

    QCOMPARE(curve.overshoot(), qreal(1.70158f));

    curve.setType(QEasingCurve::InBounce);

    QCOMPARE(curve.period(), 0.3);

    QCOMPARE(curve.amplitude(), 1.0);

    QCOMPARE(curve.overshoot(), qreal(1.70158f));

    curve.setType(QEasingCurve::Linear);

    QCOMPARE(curve.period(), 0.3);

    QCOMPARE(curve.amplitude(), 1.0);

    QCOMPARE(curve.overshoot(), qreal(1.70158f));

    curve.setType(QEasingCurve::InElastic);

    QCOMPARE(curve.period(), 0.3);

    QCOMPARE(curve.amplitude(), 1.0);

    QCOMPARE(curve.overshoot(), qreal(1.70158f));

    curve.setPeriod(0.4);

    curve.setAmplitude(0.6);

    curve.setOvershoot(1.0);

    curve.setType(QEasingCurve::Linear);

    QCOMPARE(curve.period(), 0.4);

    QCOMPARE(curve.amplitude(), 0.6);

    QCOMPARE(curve.overshoot(), 1.0);

    curve.setType(QEasingCurve::InElastic);

    QCOMPARE(curve.period(), 0.4);

    QCOMPARE(curve.amplitude(), 0.6);

    QCOMPARE(curve.overshoot(), 1.0);

    }

}

typedef QList<int> IntList;

typedef QList<qreal> RealList;

Q_DECLARE_METATYPE(IntList)

Q_DECLARE_METATYPE(RealList)

void tst_QEasingCurve::valueForProgress_data()

{

    QTest::addColumn<int>("type");

    QTest::addColumn<IntList>("at");

    QTest::addColumn<RealList>("expected");

    // automatically generated.

    // note that values are scaled from range [0,1] to range [0, 100] in order to store them as

    // integer values and avoid fp inaccuracies

    QTest::newRow("Linear") << int(QEasingCurve::Linear)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InQuad") << int(QEasingCurve::InQuad)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutQuad") << int(QEasingCurve::OutQuad)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InOutQuad") << int(QEasingCurve::InOutQuad)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutInQuad") << int(QEasingCurve::OutInQuad)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InCubic") << int(QEasingCurve::InCubic)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutCubic") << int(QEasingCurve::OutCubic)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InOutCubic") << int(QEasingCurve::InOutCubic)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutInCubic") << int(QEasingCurve::OutInCubic)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InQuart") << int(QEasingCurve::InQuart)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutQuart") << int(QEasingCurve::OutQuart)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InOutQuart") << int(QEasingCurve::InOutQuart)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutInQuart") << int(QEasingCurve::OutInQuart)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InQuint") << int(QEasingCurve::InQuint)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutQuint") << int(QEasingCurve::OutQuint)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InOutQuint") << int(QEasingCurve::InOutQuint)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutInQuint") << int(QEasingCurve::OutInQuint)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InSine") << int(QEasingCurve::InSine)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutSine") << int(QEasingCurve::OutSine)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InOutSine") << int(QEasingCurve::InOutSine)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutInSine") << int(QEasingCurve::OutInSine)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InExpo") << int(QEasingCurve::InExpo)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutExpo") << int(QEasingCurve::OutExpo)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InOutExpo") << int(QEasingCurve::InOutExpo)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutInExpo") << int(QEasingCurve::OutInExpo)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InCirc") << int(QEasingCurve::InCirc)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutCirc") << int(QEasingCurve::OutCirc)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InOutCirc") << int(QEasingCurve::InOutCirc)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutInCirc") << int(QEasingCurve::OutInCirc)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InElastic") << int(QEasingCurve::InElastic)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutElastic") << int(QEasingCurve::OutElastic)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InOutElastic") << int(QEasingCurve::InOutElastic)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutInElastic") << int(QEasingCurve::OutInElastic)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InBack") << int(QEasingCurve::InBack)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutBack") << int(QEasingCurve::OutBack)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InOutBack") << int(QEasingCurve::InOutBack)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutInBack") << int(QEasingCurve::OutInBack)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InBounce") << int(QEasingCurve::InBounce)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutBounce") << int(QEasingCurve::OutBounce)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InOutBounce") << int(QEasingCurve::InOutBounce)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutInBounce") << int(QEasingCurve::OutInBounce)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("InCurve") << int(QEasingCurve::InCurve)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("OutCurve") << int(QEasingCurve::OutCurve)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("SineCurve") << int(QEasingCurve::SineCurve)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

    QTest::newRow("CosineCurve") << int(QEasingCurve::CosineCurve)

         << (IntList()  << 0 << 10 << 20 << 30 << 40 << 50 << 60 << 70 << 80 << 90 << 100)

}

void tst_QEasingCurve::valueForProgress()

{

#if 0

    // used to generate data tables...

    QFile out;

    out.open(stdout, QIODevice::WriteOnly);

    for (int c = QEasingCurve::Linear; c < QEasingCurve::NCurveTypes - 1; ++c) {

        QEasingCurve curve((QEasingCurve::Type)c);

        QMetaObject mo = QEasingCurve::staticMetaObject;

        QString strCurve = QLatin1String(mo.enumerator(mo.indexOfEnumerator("Type")).key(c));

        QString strInputs;

        QString strOutputs;

        for (int t = 0; t <= 100; t+= 10) {

            qreal ease = curve.valueForProgress(t/qreal(100));

            strInputs += QString::fromAscii(" << %1").arg(t);

        }

        QString str = QString::fromAscii("    QTest::newRow(\"%1\") << int(QEasingCurve::%2)\n"

                                                "         << (IntList() %3)\n"

                                                "         << (RealList()%4);\n\n")

                                      .arg(strCurve)

                                      .arg(strCurve)

                                      .arg(strInputs)

                                      .arg(strOutputs);

        out.write(str.toLatin1().constData());

    }

    out.close();

    exit(1);

#else

    QFETCH(int, type);

    QFETCH(IntList, at);

    QFETCH(RealList, expected);

    QEasingCurve curve((QEasingCurve::Type)type);

    for (int i = 0; i < at.count(); ++i) {

    }

#endif

}

static qreal discreteEase(qreal progress)

{

    return qFloor(progress * 10) / qreal(10.0);

}

void tst_QEasingCurve::setCustomType()

{

    QEasingCurve curve;

    curve.setCustomType(&discreteEase);

    QCOMPARE(curve.type(), QEasingCurve::Custom);

    QCOMPARE(curve.valueForProgress(0.0), 0.0);

    QCOMPARE(curve.valueForProgress(0.05), 0.0);

    QCOMPARE(curve.valueForProgress(0.10), 0.1);

    QCOMPARE(curve.valueForProgress(0.15), 0.1);

    QCOMPARE(curve.valueForProgress(0.20), 0.2);

    QCOMPARE(curve.valueForProgress(0.25), 0.2);

    QCOMPARE(curve.valueForProgress(0.30), 0.3);

    QCOMPARE(curve.valueForProgress(0.35), 0.3);

    QCOMPARE(curve.valueForProgress(0.999999), 0.9);

    curve.setType(QEasingCurve::Linear);

    QCOMPARE(curve.type(), QEasingCurve::Linear);

    QCOMPARE(curve.valueForProgress(0.0), 0.0);

    QCOMPARE(curve.valueForProgress(0.1), 0.1);

    QCOMPARE(curve.valueForProgress(0.5), 0.5);

    QCOMPARE(curve.valueForProgress(0.99), 0.99);

}

void tst_QEasingCurve::operators()

{

    // operator=

    QEasingCurve curve;

    QEasingCurve curve2;

    curve.setCustomType(&discreteEase);

    curve2 = curve;

    QCOMPARE(curve2.type(), QEasingCurve::Custom);

    QCOMPARE(curve2.valueForProgress(0.0), 0.0);

    QCOMPARE(curve2.valueForProgress(0.05), 0.0);

    QCOMPARE(curve2.valueForProgress(0.15), 0.1);

    QCOMPARE(curve2.valueForProgress(0.25), 0.2);

    QCOMPARE(curve2.valueForProgress(0.35), 0.3);

    QCOMPARE(curve2.valueForProgress(0.999999), 0.9);

    // operator==

    curve.setType(QEasingCurve::InBack);

    curve2 = curve;

    curve2.setOvershoot(qreal(1.70158f));

    QCOMPARE(curve.overshoot(), curve2.overshoot());

    QVERIFY(curve2 == curve);

    curve.setOvershoot(3.0);

    QVERIFY(curve2 != curve);

    curve2.setOvershoot(3.0);

    QVERIFY(curve2 == curve);

    curve2.setType(QEasingCurve::Linear);

    QCOMPARE(curve.overshoot(), curve2.overshoot());

    QVERIFY(curve2 != curve);

    curve2.setType(QEasingCurve::InBack);

    QCOMPARE(curve.overshoot(), curve2.overshoot());

    QVERIFY(curve2 == curve);

}