Initial import of statemachine branch from the old kinetic repository

2 files changed, 836 insertions, 0 deletions

diff --git a/tests/auto/qpropertyanimation/qpropertyanimation.pro b/tests/auto/qpropertyanimation/qpropertyanimation.pro
new file mode 100644
index 0000000..6d6ddbf
--- /dev/null
+++ b/tests/auto/qpropertyanimation/qpropertyanimation.pro
@@ -0,0 +1,5 @@
+load(qttest_p4)
+QT = core gui
+SOURCES  += tst_qpropertyanimation.cpp
+
+
diff --git a/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
new file mode 100644
index 0000000..f61df49
--- /dev/null
+++ b/tests/auto/qpropertyanimation/tst_qpropertyanimation.cpp
@@ -0,0 +1,831 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+
+#include <QtCore/qpropertyanimation.h>
+#include <QtGui/qitemanimation.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 msecs)
+    {
+        QPropertyAnimation::updateCurrentTime(msecs);
+        if (msecs >= QPropertyAnimation::duration())
+            stop();
+    }
+};
+
+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 startWhenAnotherIsRunning();
+    void easingcurve_data();
+    void easingcurve();
+    void startWithoutStartValue();
+    void playForwardBackward();
+    void interpolated();
+    void setStartEndValues();
+    void zeroDurationStart();
+    void operationsInStates_data();
+    void operationsInStates();
+};
+
+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)
+    { }
+
+    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>("iterationCount");
+    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, iterationCount);
+    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.setIterationCount(iterationCount);
+    animation.setCurrentTime(currentTime);
+
+    QCOMPARE(animation.currentTime(), testCurrentTime);
+    QCOMPARE(animation.currentIteration(), 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 = uncontrolled ? new UncontrolledAnimation : new QPropertyAnimation;
+    anim->setDuration(100);
+
+    QSignalSpy finishedSpy(anim, SIGNAL(finished()));
+    QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    QSignalSpy currentLoopSpy(anim, SIGNAL(currentIterationChanged(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->setIterationCount(3);
+    anim->setCurrentTime(101);
+
+    if (uncontrolled)
+        QSKIP("Uncontrolled animations don't handle looping", SkipSingle);
+
+    QCOMPARE(currentLoopSpy.count(), 1);
+    QCOMPARE(anim->currentIteration(), 1);
+
+    anim->setCurrentTime(0);
+    QCOMPARE(currentLoopSpy.count(), 2);
+    QCOMPARE(anim->currentIteration(), 0);
+
+    anim->start();
+    QCOMPARE(anim->state(), QAnimationGroup::Running);
+    QCOMPARE(runningSpy.count(), 1); //anim must have started
+    QCOMPARE(anim->currentIteration(), 0);
+    runningSpy.clear();
+
+    anim->stop();
+    QCOMPARE(anim->state(), QAnimationGroup::Stopped);
+    QCOMPARE(runningSpy.count(), 1); //anim must have stopped
+    QCOMPARE(finishedSpy.count(), 0);
+    QCOMPARE(anim->currentTime(), 0);
+    QCOMPARE(anim->currentIteration(), 0);
+    QCOMPARE(currentLoopSpy.count(), 2);
+    runningSpy.clear();
+
+    anim->start();
+    QTest::qWait(1000);
+    QCOMPARE(anim->state(), QAnimationGroup::Stopped);
+    QCOMPARE(runningSpy.count(), 2); //started and stopped again
+    runningSpy.clear();
+    QCOMPARE(finishedSpy.count(), 1);
+    QCOMPARE(anim->currentTime(), 100);
+    QCOMPARE(anim->currentIteration(), 2);
+    QCOMPARE(currentLoopSpy.count(), 4);
+
+    anim->start(); // auto-rewinds
+    QCOMPARE(anim->state(), QAnimationGroup::Running);
+    QCOMPARE(anim->currentTime(), 0);
+    QCOMPARE(anim->currentIteration(), 0);
+    QCOMPARE(currentLoopSpy.count(), 5);
+    QCOMPARE(runningSpy.count(), 1); // anim has started
+    QCOMPARE(finishedSpy.count(), 1);
+    QCOMPARE(anim->currentIteration(), 0);
+    runningSpy.clear();
+
+    QTest::qWait(1000);
+
+    QCOMPARE(currentLoopSpy.count(), 7);
+    QCOMPARE(anim->state(), QAnimationGroup::Stopped);
+    QCOMPARE(anim->currentIteration(), 2);
+    QCOMPARE(runningSpy.count(), 1); // anim has stopped
+    QCOMPARE(finishedSpy.count(), 2);
+    QCOMPARE(anim->currentTime(), 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(anim->state(), QAnimationGroup::Stopped);
+    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
+    QCOMPARE(runningSpy.count(), 4);
+    QCOMPARE(finishedSpy.count(), 2);
+    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 iteration 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);
+    QCOMPARE(o.property("ole").toInt(), 42);
+    animation.setDuration(0);
+    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.first(), 42);
+    QCOMPARE(o.values.last(), 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");
+        QSignalSpy runningSpy(anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+        anim->start(QVariantAnimation::DeleteWhenStopped);
+        QTest::qWait(anim->duration() + 50);
+        QCOMPARE(runningSpy.count(), 2); //started and then stopped
+        QVERIFY(!anim);
+    }
+
+    {
+        QPointer<QVariantAnimation> anim = new QPropertyAnimation(&o, "ole");
+        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");
+        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(!anim2); //anim2 is finished: it should have been deleted by now
+        QVERIFY(!anim);
+    }
+
+}
+
+// copy  from easing.cpp in case that function changes definition
+static qreal easeInOutBack(qreal t)
+{
+    qreal s = 1.70158;
+    qreal t_adj = 2.0f * (qreal)t;
+    if (t_adj < 1) {
+        s *= 1.525f;
+        return 1.0/2*(t_adj*t_adj*((s+1)*t_adj - s));
+    } else {
+        t_adj -= 2;
+        s *= 1.525f;
+        return 1.0/2*(t_adj*t_adj*((s+1)*t_adj + s) + 2);
+    }
+}
+
+void tst_QPropertyAnimation::easingcurve_data()
+{
+    QTest::addColumn<int>("currentTime");
+    QTest::addColumn<int>("expectedvalue");
+
+    QTest::newRow("interpolation1") << 0 << 0;
+    QTest::newRow("interpolation2") << 1000 << 1000;
+    QTest::newRow("extrapolationbelow") << 250 << -99;
+    QTest::newRow("extrapolationabove") << 750 << 1099;
+}
+
+void tst_QPropertyAnimation::easingcurve()
+{
+    QFETCH(int, currentTime);
+    QFETCH(int, expectedvalue);
+    QObject o;
+    o.setProperty("ole", 42);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    QPropertyAnimation pAnimation(&o, "ole");
+    pAnimation.setStartValue(0);
+    pAnimation.setEndValue(1000);
+    pAnimation.setDuration(1000);
+
+    // this easingcurve assumes that we extrapolate before startValue and after endValue
+    QEasingCurve easingCurve;
+    easingCurve.setCustomType(easeInOutBack);
+    pAnimation.setEasingCurve(easingCurve);
+    pAnimation.start();
+    pAnimation.pause();
+    pAnimation.setCurrentTime(currentTime);
+    QCOMPARE(o.property("ole").toInt(), expectedvalue);
+}
+
+void tst_QPropertyAnimation::startWithoutStartValue()
+{
+    QObject o;
+    o.setProperty("ole", 42);
+    QCOMPARE(o.property("ole").toInt(), 42);
+
+    QPropertyAnimation anim(&o, "ole");
+    anim.setEndValue(100);
+
+    anim.start();
+
+    QTest::qWait(100);
+    int current = anim.currentValue().toInt();
+    //it is somewhere in the animation
+    QVERIFY(current > 42);
+    QVERIFY(current < 100);
+
+    QTest::qWait(200);
+    QCOMPARE(anim.state(), QVariantAnimation::Stopped);
+
+    anim.setEndValue(110);
+    anim.start();
+    current = anim.currentValue().toInt();
+    QCOMPARE(current, 42); // the initial default start value
+
+    QTest::qWait(100);
+    current = anim.currentValue().toInt();
+    //it is somewhere in the animation
+    QVERIFY(current > 42);
+    QVERIFY(current < 110);
+}
+
+void tst_QPropertyAnimation::playForwardBackward()
+{
+    QObject o;
+    o.setProperty("ole", 0);
+    QCOMPARE(o.property("ole").toInt(), 0);
+
+    QPropertyAnimation anim(&o, "ole");
+    anim.setEndValue(100);
+    anim.start();
+    QTest::qWait(anim.duration() + 50);
+    QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
+    QCOMPARE(anim.currentTime(), anim.duration());
+
+    //the animation is at the end
+    anim.setDirection(QVariantAnimation::Backward);
+    anim.start();
+    QCOMPARE(anim.state(), QAbstractAnimation::Running);
+    QTest::qWait(anim.duration() + 50);
+    QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
+    QCOMPARE(anim.currentTime(), 0);
+
+    //the direction is backward
+    //restarting should jump to the end
+    anim.start();
+    QCOMPARE(anim.state(), QAbstractAnimation::Running);
+    QCOMPARE(anim.currentTime(), anim.duration());
+    QTest::qWait(anim.duration() + 50);
+    QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
+    QCOMPARE(anim.currentTime(), 0);
+}
+
+struct Number
+{
+    Number() {}
+    Number(int n)
+        : n(n) {}
+
+    Number(const Number &other)
+        : n(other.n){}
+
+    Number &operator=(const Number &other) {
+        n = other.n;
+        return *this;
+    }
+    bool operator==(const Number &other) const {
+        return n == other.n;
+    }
+
+    int n;
+};
+
+Q_DECLARE_METATYPE(Number)
+Q_DECLARE_METATYPE(QAbstractAnimation::State)
+
+QVariant numberInterpolator(const Number &f, const Number &t, qreal progress)
+{
+    return qVariantFromValue<Number>(Number(f.n + (t.n - f.n)*progress));
+}
+
+QVariant xaxisQPointInterpolator(const QPointF &f, const QPointF &t, qreal progress)
+{
+    return QPointF(f.x() + (t.x() - f.x())*progress, f.y());
+}
+
+void tst_QPropertyAnimation::interpolated()
+{
+    QObject o;
+    o.setProperty("number", qVariantFromValue<Number>(Number(42)));
+    QCOMPARE(qVariantValue<Number>(o.property("number")), Number(42));
+    {
+    qRegisterAnimationInterpolator<Number>(numberInterpolator);
+    QPropertyAnimation anim(&o, "number");
+    anim.setStartValue(qVariantFromValue<Number>(Number(0)));
+    anim.setEndValue(qVariantFromValue<Number>(Number(100)));
+    anim.setDuration(1000);
+    anim.start();
+    anim.pause();
+    anim.setCurrentTime(100);
+    Number t(qVariantValue<Number>(o.property("number")));
+    QCOMPARE(t, Number(10));
+    anim.setCurrentTime(500);
+    QCOMPARE(qVariantValue<Number>(o.property("number")), Number(50));
+    }
+    {
+    qRegisterAnimationInterpolator<QPointF>(xaxisQPointInterpolator);
+    QPropertyAnimation anim(&o, "point");
+    anim.setStartValue(QPointF(0,0));
+    anim.setEndValue(QPointF(100, 100));
+    anim.setDuration(1000);
+    anim.start();
+    anim.pause();
+    anim.setCurrentTime(100);
+    QCOMPARE(o.property("point").toPointF(), QPointF(10, 0));
+    anim.setCurrentTime(500);
+    QCOMPARE(o.property("point").toPointF(), QPointF(50, 0));
+    }
+    {
+    // unregister it and see if we get back the default behaviour
+    qRegisterAnimationInterpolator<QPointF>(0);
+    QPropertyAnimation anim(&o, "point");
+    anim.setStartValue(QPointF(0,0));
+    anim.setEndValue(QPointF(100, 100));
+    anim.setDuration(1000);
+    anim.start();
+    anim.pause();
+    anim.setCurrentTime(100);
+    QCOMPARE(o.property("point").toPointF(), QPointF(10, 10));
+    anim.setCurrentTime(500);
+    QCOMPARE(o.property("point").toPointF(), QPointF(50, 50));
+    }
+
+    {
+    // Interpolate a qreal property with a int interpolator
+    AnimationObject o1;
+    o1.setRealValue(42.42);
+    QPropertyAnimation anim(&o1, "realValue");
+    anim.setStartValue(0);
+    anim.setEndValue(100);
+    anim.start();
+    QCOMPARE(o1.realValue(), qreal(0));
+    anim.setCurrentTime(250);
+    QCOMPARE(o1.realValue(), qreal(100));
+    }
+}
+
+void tst_QPropertyAnimation::setStartEndValues()
+{
+    //this tests the start value, end value and default start value
+    QObject o;
+    o.setProperty("ole", 42);
+    QPropertyAnimation anim(&o, "ole");
+    QVariantAnimation::KeyValues values;
+    QCOMPARE(anim.keyValues(), values);
+
+    //let's add a start value
+    anim.setStartValue(0);
+    values << QVariantAnimation::KeyValue(0, 0);
+    QCOMPARE(anim.keyValues(), values);
+
+    anim.setEndValue(10);
+    values << QVariantAnimation::KeyValue(1, 10);
+    QCOMPARE(anim.keyValues(), values);
+
+    //now we can play with objects
+    QCOMPARE(o.property("ole").toInt(), 42);
+    QCOMPARE(o.property("ole").toInt(), 42);
+    anim.start();
+    QVERIFY(anim.startValue().isValid());
+    QCOMPARE(o.property("ole"), anim.startValue());
+
+    //now we remove the explicit start value and test the implicit one
+    anim.stop();
+    o.setProperty("ole", 42);
+    values.remove(0);
+    anim.setStartValue(QVariant()); //reset the start value
+    QCOMPARE(anim.keyValues(), values);
+    QVERIFY(!anim.startValue().isValid());
+    anim.start();
+    QCOMPARE(o.property("ole").toInt(), 42);
+    anim.setCurrentTime(anim.duration()/2);
+    QCOMPARE(o.property("ole").toInt(), 26); //just in the middle of the animation
+    anim.setCurrentTime(anim.duration());
+    QCOMPARE(anim.state(), QAnimationGroup::Stopped); //it should have stopped
+    QVERIFY(anim.endValue().isValid());
+    QCOMPARE(o.property("ole"), anim.endValue()); //end of the animations
+
+    //now we set back the startValue
+    anim.setStartValue(5);
+    QVERIFY(anim.startValue().isValid());
+    anim.start();
+    QCOMPARE(o.property("ole").toInt(), 5);
+}
+
+void tst_QPropertyAnimation::zeroDurationStart()
+{
+    QPropertyAnimation anim;
+    QSignalSpy spy(&anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+    anim.setDuration(0);
+    QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
+    anim.start();
+    //the animation stops immediately
+    QCOMPARE(anim.state(), QAbstractAnimation::Stopped);
+    QCOMPARE(spy.count(), 2);
+
+    //let's check the first state change
+    const QVariantList firstChange = spy.first();
+    //old state
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.first()), QAbstractAnimation::Stopped);
+    //new state
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(firstChange.last()), QAbstractAnimation::Running);
+
+    //let's check the first state change
+    const QVariantList secondChange = spy.last();
+    //old state
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.first()), QAbstractAnimation::Running);
+    //new state
+    QCOMPARE(qVariantValue<QAbstractAnimation::State>(secondChange.last()), QAbstractAnimation::Stopped);
+}
+
+#define Pause 1
+#define Start 2
+#define Resume 3
+#define Stop 4
+
+void tst_QPropertyAnimation::operationsInStates_data()
+{
+    QTest::addColumn<QAbstractAnimation::State>("originState");
+    QTest::addColumn<int>("operation");
+    QTest::addColumn<QString>("expectedWarning");
+    QTest::addColumn<QAbstractAnimation::State>("expectedState");
+
+    QString pauseWarn(QLatin1String("QAbstractAnimation::pause: Cannot pause a stopped animation"));
+    QString resumeWarn(QLatin1String("QAbstractAnimation::resume: Cannot resume an animation that is not paused"));
+
+    QTest::newRow("S-pause")  << QAbstractAnimation::Stopped << Pause << pauseWarn << QAbstractAnimation::Stopped;
+    QTest::newRow("S-start")  << QAbstractAnimation::Stopped << Start << QString() << QAbstractAnimation::Running;
+    QTest::newRow("S-resume") << QAbstractAnimation::Stopped << Resume << resumeWarn << QAbstractAnimation::Stopped;
+    QTest::newRow("S-stop")   << QAbstractAnimation::Stopped << Stop << QString() << QAbstractAnimation::Stopped;
+
+    QTest::newRow("P-pause")  << QAbstractAnimation::Paused << Pause << QString() << QAbstractAnimation::Paused;
+    QTest::newRow("P-start")  << QAbstractAnimation::Paused << Start << QString() << QAbstractAnimation::Running;
+    QTest::newRow("P-resume") << QAbstractAnimation::Paused << Resume << QString() << QAbstractAnimation::Running;
+    QTest::newRow("P-stop")   << QAbstractAnimation::Paused << Stop << QString() << QAbstractAnimation::Stopped;
+
+    QTest::newRow("R-pause")  << QAbstractAnimation::Running << Pause << QString() << QAbstractAnimation::Paused;
+    QTest::newRow("R-start")  << QAbstractAnimation::Running << Start << QString() << QAbstractAnimation::Running;
+    QTest::newRow("R-resume") << QAbstractAnimation::Running << Resume << resumeWarn << QAbstractAnimation::Running;
+    QTest::newRow("R-stop")   << QAbstractAnimation::Running << Stop << QString() << QAbstractAnimation::Stopped;
+}
+
+void tst_QPropertyAnimation::operationsInStates()
+{
+/**
+ *           | pause()    |start()    |resume()   |stop()
+ * ----------+------------+-----------+-----------+-------------------+
+ * Stopped   | Stopped    |Running    |Stopped    |Stopped            |
+ *          _| qWarning   |           |qWarning   |-                  |
+ * Paused    | Paused     |Running    |Running    |Stopped            |
+ *          _| -          |           |           |                   |
+ * Running   | Paused     |Running    |Running    |Stopped            |
+ *           |            |restart    |qWarning   |                   |
+ * ----------+------------+-----------+-----------+-------------------+
+**/
+
+    QFETCH(QAbstractAnimation::State, originState);
+    QFETCH(int, operation);
+    QFETCH(QString, expectedWarning);
+    QFETCH(QAbstractAnimation::State, expectedState);
+
+    QObject o;
+    o.setProperty("ole", 42);
+    QPropertyAnimation anim(&o, "ole");
+    QSignalSpy spy(&anim, SIGNAL(stateChanged(QAbstractAnimation::State, QAbstractAnimation::State)));
+
+    anim.stop();
+    switch (originState) {
+    case QAbstractAnimation::Stopped:
+    break;
+    case QAbstractAnimation::Paused:
+        anim.start();
+        anim.pause();
+    break;
+    case QAbstractAnimation::Running:
+        anim.start();
+    break;
+    }
+    if (!expectedWarning.isEmpty()) {
+        QTest::ignoreMessage(QtWarningMsg, qPrintable(expectedWarning));
+    }
+    QCOMPARE(anim.state(), originState);
+    switch (operation) {
+    case Pause:
+        anim.pause();
+    break;
+    case Start:
+        anim.start();
+    break;
+    case Resume:
+        anim.resume();
+    break;
+    case Stop:
+        anim.stop();
+    break;
+    }
+
+    QCOMPARE(anim.state(), expectedState);
+}
+#undef Pause
+#undef Start
+#undef Resume
+#undef Stop
+
+QTEST_MAIN(tst_QPropertyAnimation)
+#include "tst_qpropertyanimation.moc"