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

**

** 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 <QtCore/qpropertyanimation.h>

#include <QtCore/qvariantanimation.h>

#include <QtGui/qwidget.h>

//TESTED_CLASS=QPropertyAnimation

//TESTED_FILES=

class UncontrolledAnimation : public QPropertyAnimation

{

    Q_OBJECT

public:

    int duration() const { return -1; /* not time driven */ }

protected:

    void updateCurrentTime(int currentTime)

    {

        QPropertyAnimation::updateCurrentTime(currentTime);

        if (currentTime >= QPropertyAnimation::duration() || currentLoop() >= 1)

            stop();

    }

};

class MyObject : public QObject

{

    Q_OBJECT

    Q_PROPERTY(qreal x READ x WRITE setX)

public:

    MyObject() : m_x(0) { }

    qreal x() const { return m_x; }

    void setX(qreal x) { m_x = x; }

private:

    qreal m_x;

};

class DummyPropertyAnimation : public QPropertyAnimation

{

public:

    DummyPropertyAnimation(QObject *parent = 0) : QPropertyAnimation(parent)

    {

        setTargetObject(&o);

        this->setPropertyName("x");

        setEndValue(100);

    }

    MyObject o;

};

class tst_QPropertyAnimation : public QObject

{

  Q_OBJECT

public:

    tst_QPropertyAnimation();

    virtual ~tst_QPropertyAnimation();

public Q_SLOTS:

    void init();

    void cleanup();

private slots:

    void construction();

    void setCurrentTime_data();

    void setCurrentTime();

    void statesAndSignals_data();

    void statesAndSignals();

    void deletion1();

    void deletion2();

    void deletion3();

    void duration0();

    void noStartValue();

    void noStartValueWithLoop();

    void startWhenAnotherIsRunning();

    void easingcurve_data();

    void easingcurve();

    void startWithoutStartValue();

    void startBackwardWithoutEndValue();

    void playForwardBackward();

    void interpolated();

    void setStartEndValues_data();

    void setStartEndValues();

    void zeroDurationStart();

    void operationsInStates_data();

    void operationsInStates();

    void oneKeyValue();

    void updateOnSetKeyValues();

    void restart();

    void valueChanged();

    void twoAnimations();

    void deletedInUpdateCurrentTime();

    void totalDuration();

};

tst_QPropertyAnimation::tst_QPropertyAnimation()

{

}

tst_QPropertyAnimation::~tst_QPropertyAnimation()

{

}

void tst_QPropertyAnimation::init()

{

    qRegisterMetaType<QAbstractAnimation::State>("QAbstractAnimation::State");

    qRegisterMetaType<QAbstractAnimation::DeletionPolicy>("QAbstractAnimation::DeletionPolicy");

}

void tst_QPropertyAnimation::cleanup()

{

}

class AnimationObject : public QObject

{

    Q_OBJECT

    Q_PROPERTY(int value READ value WRITE setValue)

    Q_PROPERTY(qreal realValue READ realValue WRITE setRealValue)

public:

    AnimationObject(int startValue = 0)

        : v(startValue), rv(startValue)

    { }

    int value() const { return v; }

    void setValue(int value) { v = value; }

    qreal realValue() const { return rv; }

    void setRealValue(qreal value) { rv = value; }

    int v;

    qreal rv;

};

void tst_QPropertyAnimation::construction()

{

    QPropertyAnimation panimation;

}

void tst_QPropertyAnimation::setCurrentTime_data()

{

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

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

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

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

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

    QTest::newRow("-1") << -1 << 1 << 0 << 0 << 0;

    QTest::newRow("0")  <<  0 << 1 << 0 << 0 << 0;

    QTest::newRow("1")  <<  0 << 1 << 1 << 0 << 0;

    QTest::newRow("2")  <<  0 << 2 << 1 << 0 << 0;

    QTest::newRow("3")  <<  1 << 1 << 0 << 0 << 0;

    QTest::newRow("4")  <<  1 << 1 << 1 << 1 << 0;

    QTest::newRow("5")  <<  1 << 2 << 1 << 0 << 1;

    QTest::newRow("6")  <<  1 << 2 << 2 << 1 << 1;

    QTest::newRow("7")  <<  1 << 2 << 3 << 1 << 1;

    QTest::newRow("8")  <<  1 << 3 << 2 << 0 << 2;

    QTest::newRow("9")  <<  1 << 3 << 3 << 1 << 2;

    QTest::newRow("a") <<  10 << 1 << 0 << 0 << 0;

    QTest::newRow("b") <<  10 << 1 << 1 << 1 << 0;

    QTest::newRow("c") <<  10 << 1 << 10 << 10 << 0;

    QTest::newRow("d") <<  10 << 2 << 10 << 0 << 1;

    QTest::newRow("e") <<  10 << 2 << 11 << 1 << 1;

    QTest::newRow("f") <<  10 << 2 << 20 << 10 << 1;

    QTest::newRow("g") <<  10 << 2 << 21 << 10 << 1;

    QTest::newRow("negloop 0") <<  10 << -1 << 0 << 0 << 0;

    QTest::newRow("negloop 1") <<  10 << -1 << 10 << 0 << 1;

    QTest::newRow("negloop 2") <<  10 << -1 << 15 << 5 << 1;

    QTest::newRow("negloop 3") <<  10 << -1 << 20 << 0 << 2;

    QTest::newRow("negloop 4") <<  10 << -1 << 30 << 0 << 3;

}

void tst_QPropertyAnimation::setCurrentTime()

{

    QFETCH(int, duration);

    QFETCH(int, loopCount);

    QFETCH(int, currentTime);

    QFETCH(int, testCurrentTime);

    QFETCH(int, testCurrentLoop);

    QPropertyAnimation animation;

    if (duration < 0)

        QTest::ignoreMessage(QtWarningMsg, "QVariantAnimation::setDuration: cannot set a negative duration");

    animation.setDuration(duration);

    animation.setLoopCount(loopCount);

    animation.setCurrentTime(currentTime);

    QCOMPARE(animation.currentLoopTime(), testCurrentTime);

    QCOMPARE(animation.currentLoop(), testCurrentLoop);

}

void tst_QPropertyAnimation::statesAndSignals_data()

{

    QTest::addColumn<bool>("uncontrolled");

    QTest::newRow("normal animation") << false;

    QTest::newRow("animation with undefined duration")  <<  true;

}

void tst_QPropertyAnimation::statesAndSignals()

{

    QFETCH(bool, uncontrolled);

    QPropertyAnimation *anim;

    if (uncontrolled)

        anim = new UncontrolledAnimation;

    else

        anim = new DummyPropertyAnimation;

    anim->setDuration(100);

    QSignalSpy finishedSpy(anim, SIGNAL(finished()));

    QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));

    QSignalSpy currentLoopSpy(anim, SIGNAL(currentLoopChanged(int)));

    anim->setCurrentTime(1);

    anim->setCurrentTime(100);

    QCOMPARE(finishedSpy.count(), 0);

    QCOMPARE(runningSpy.count(), 0);

    QCOMPARE(currentLoopSpy.count(), 0);

    QCOMPARE(anim->state(), QAnimationGroup::Stopped);

    anim->setLoopCount(3);

    anim->setCurrentTime(101);

    if (uncontrolled)

        QSKIP("Uncontrolled animations don't handle looping", SkipSingle);

    QCOMPARE(currentLoopSpy.count(), 1);

    QCOMPARE(anim->currentLoop(), 1);

    anim->setCurrentTime(0);

    QCOMPARE(currentLoopSpy.count(), 2);

    QCOMPARE(anim->currentLoop(), 0);

    anim->start();

    QCOMPARE(anim->state(), QAnimationGroup::Running);

    QCOMPARE(runningSpy.count(), 1); //anim must have started

    QCOMPARE(anim->currentLoop(), 0);

    runningSpy.clear();

    anim->stop();

    QCOMPARE(anim->state(), QAnimationGroup::Stopped);

    QCOMPARE(runningSpy.count(), 1); //anim must have stopped

    QCOMPARE(finishedSpy.count(), 0);

    QCOMPARE(anim->currentLoopTime(), 0);

    QCOMPARE(anim->currentLoop(), 0);

    QCOMPARE(currentLoopSpy.count(), 2);

    runningSpy.clear();

    anim->start();

    QTest::qWait(1000);

    QCOMPARE(runningSpy.count(), 2); //started and stopped again

    runningSpy.clear();

    QCOMPARE(finishedSpy.count(), 1);

    QCOMPARE(anim->currentLoopTime(), 100);

    QCOMPARE(anim->currentLoop(), 2);

    QCOMPARE(currentLoopSpy.count(), 4);

    anim->start(); // auto-rewinds

    QCOMPARE(anim->state(), QAnimationGroup::Running);

    QCOMPARE(anim->currentTime(), 0);

    QCOMPARE(anim->currentLoop(), 0);

    QCOMPARE(currentLoopSpy.count(), 5);

    QCOMPARE(runningSpy.count(), 1); // anim has started

    QCOMPARE(finishedSpy.count(), 1);

    QCOMPARE(anim->currentLoop(), 0);

    runningSpy.clear();

    QTest::qWait(1000);

    QCOMPARE(currentLoopSpy.count(), 7);

    QCOMPARE(anim->state(), QAnimationGroup::Stopped);

    QCOMPARE(anim->currentLoop(), 2);

    QCOMPARE(runningSpy.count(), 1); // anim has stopped

    QCOMPARE(finishedSpy.count(), 2);

    QCOMPARE(anim->currentLoopTime(), 100);

    delete anim;

}

void tst_QPropertyAnimation::deletion1()

{

    QObject *object = new QWidget;

    QPointer<QPropertyAnimation> anim = new QPropertyAnimation(object, "minimumWidth");

    //test that the animation is deleted correctly depending of the deletion flag passed in start()

    QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));

    QSignalSpy finishedSpy(anim, SIGNAL(finished()));

    anim->setStartValue(10);

    anim->setEndValue(20);

    anim->setDuration(200);

    anim->start();

    QCOMPARE(runningSpy.count(), 1);

    QCOMPARE(finishedSpy.count(), 0);

    QVERIFY(anim);

    QCOMPARE(anim->state(), QAnimationGroup::Running);

    QTest::qWait(100);

    QVERIFY(anim);

    QCOMPARE(anim->state(), QAnimationGroup::Running);

    QTest::qWait(150);

    QVERIFY(anim); //The animation should not have been deleted

    QCOMPARE(runningSpy.count(), 2);

    QCOMPARE(finishedSpy.count(), 1);

    anim->start(QVariantAnimation::DeleteWhenStopped);

    QVERIFY(anim);

    QCOMPARE(anim->state(), QAnimationGroup::Running);

    QTest::qWait(100);

    QVERIFY(anim);

    QCOMPARE(anim->state(), QAnimationGroup::Running);

    QTest::qWait(150);

    QVERIFY(!anim);  //The animation must have been deleted

    delete object;

}

void tst_QPropertyAnimation::deletion2()

{

    //test that the animation get deleted if the object is deleted

    QObject *object = new QWidget;

    QPointer<QPropertyAnimation> anim = new QPropertyAnimation(object,"minimumWidth");

    anim->setStartValue(10);

    anim->setEndValue(20);

    anim->setDuration(200);

    QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));

    QSignalSpy finishedSpy(anim, SIGNAL(finished()));

    anim->setStartValue(10);

    anim->setEndValue(20);

    anim->setDuration(200);

    anim->start();

    QTest::qWait(50);

    QVERIFY(anim);

    QCOMPARE(anim->state(), QAnimationGroup::Running);

    QCOMPARE(runningSpy.count(), 1);

    QCOMPARE(finishedSpy.count(), 0);

    //we can't call deletaLater directly because the delete would only happen in the next loop of _this_ event loop

    QTimer::singleShot(0, object, SLOT(deleteLater()));

    QTest::qWait(50);

    QVERIFY(anim->targetObject() == 0);

}

void tst_QPropertyAnimation::deletion3()

{

    //test that the stopped signal is emit when the animation is destroyed

    QObject *object = new QWidget;

    QPropertyAnimation *anim = new QPropertyAnimation(object,"minimumWidth");

    anim->setStartValue(10);

    anim->setEndValue(20);

    anim->setDuration(200);

    QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));

    QSignalSpy finishedSpy(anim, SIGNAL(finished()));

    anim->start();

    QTest::qWait(50);

    QCOMPARE(anim->state(), QAnimationGroup::Running);

    QCOMPARE(runningSpy.count(), 1);

    QCOMPARE(finishedSpy.count(), 0);

    delete anim;

    QCOMPARE(runningSpy.count(), 2);

    QCOMPARE(finishedSpy.count(), 0);

}

void tst_QPropertyAnimation::duration0()

{

    QObject o;

    o.setProperty("ole", 42);

    QCOMPARE(o.property("ole").toInt(), 42);

    QPropertyAnimation animation(&o, "ole");

    animation.setEndValue(43);

    QVERIFY(!animation.currentValue().isValid());

    QCOMPARE(animation.currentValue().toInt(), 0);

    animation.setStartValue(42);

    QVERIFY(animation.currentValue().isValid());

    QCOMPARE(animation.currentValue().toInt(), 42);

    QCOMPARE(o.property("ole").toInt(), 42);

    animation.setDuration(0);

    QCOMPARE(animation.currentValue().toInt(), 43); //it is at the end

    animation.start();

    QCOMPARE(animation.state(), QAnimationGroup::Stopped);

    QCOMPARE(animation.currentTime(), 0);

    QCOMPARE(o.property("ole").toInt(), 43);

}

class StartValueTester : public QObject

{

    Q_OBJECT

    Q_PROPERTY(int ole READ ole WRITE setOle)

public:

    StartValueTester() : o(0) { }

    int ole() const { return o; }

    void setOle(int v) { o = v; values << v; }

    int o;

    QList<int> values;

};

void tst_QPropertyAnimation::noStartValue()

{

    StartValueTester o;

    o.setProperty("ole", 42);

    o.values.clear();

    QPropertyAnimation a(&o, "ole");

    a.setEndValue(420);

    a.setDuration(250);

    a.start();

    QTest::qWait(300);

    QCOMPARE(o.values.last(), 420);

}

void tst_QPropertyAnimation::noStartValueWithLoop()

{

    StartValueTester o;

    o.setProperty("ole", 42);

    o.values.clear();

    QPropertyAnimation a(&o, "ole");

    a.setEndValue(420);

    a.setDuration(250);

    a.setLoopCount(2);

    a.start();

    a.setCurrentTime(250);

    QCOMPARE(o.values.first(), 42);

    QCOMPARE(a.currentValue().toInt(), 42);

    QCOMPARE(o.values.last(), 42);

    a.setCurrentTime(500);

    QCOMPARE(a.currentValue().toInt(), 420);

}

void tst_QPropertyAnimation::startWhenAnotherIsRunning()

{

    StartValueTester o;

    o.setProperty("ole", 42);

    o.values.clear();

    {

        //normal case: the animation finishes and is deleted

        QPointer<QVariantAnimation> anim = new QPropertyAnimation(&o, "ole");

        anim->setEndValue(100);

        QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));

        anim->start(QVariantAnimation::DeleteWhenStopped);

        QTest::qWait(anim->duration() + 100);

        QVERIFY(!anim);

    }

    {

        QPointer<QVariantAnimation> anim = new QPropertyAnimation(&o, "ole");

        anim->setEndValue(100);

        QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));

        anim->start(QVariantAnimation::DeleteWhenStopped);

        QTest::qWait(anim->duration()/2);

        QPointer<QVariantAnimation> anim2 = new QPropertyAnimation(&o, "ole");

        anim2->setEndValue(100);

        QCOMPARE(runningSpy.count(), 1);

        QCOMPARE(anim->state(), QVariantAnimation::Running);

        //anim2 will interrupt anim1

        QMetaObject::invokeMethod(anim2, "start", Qt::QueuedConnection, Q_ARG(QAbstractAnimation::DeletionPolicy, QVariantAnimation::DeleteWhenStopped));

        QTest::qWait(50);

        QVERIFY(!anim); //anim should have been deleted

        QVERIFY(anim2);

        QTest::qWait(anim2->duration());

        QVERIFY(!anim);

    }

}