tests/auto/corelib/tools/qtimeline/tst_qtimeline.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the test suite of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** GNU Lesser General Public License Usage
  11 ** This file may be used under the terms of the GNU Lesser General Public
  12 ** License version 2.1 as published by the Free Software Foundation and
  13 ** appearing in the file LICENSE.LGPL included in the packaging of this
  14 ** file. Please review the following information to ensure the GNU Lesser
  15 ** General Public License version 2.1 requirements will be met:
  16 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  17 **
  18 ** In addition, as a special exception, Nokia gives you certain additional
  19 ** rights. These rights are described in the Nokia Qt LGPL Exception
  20 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  21 **
  22 ** GNU General Public License Usage
  23 ** Alternatively, this file may be used under the terms of the GNU General
  24 ** Public License version 3.0 as published by the Free Software Foundation
  25 ** and appearing in the file LICENSE.GPL included in the packaging of this
  26 ** file. Please review the following information to ensure the GNU General
  27 ** Public License version 3.0 requirements will be met:
  28 ** http://www.gnu.org/copyleft/gpl.html.
  29 **
  30 ** Other Usage
  31 ** Alternatively, this file may be used in accordance with the terms and
  32 ** conditions contained in a signed written agreement between you and Nokia.
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include <QtTest/QtTest>
  43
  44 #include <qtimeline.h>
  45
  46 class tst_QTimeLine : public QObject
  47 {
  48   Q_OBJECT
  49 private slots:
  50     void range();
  51     void currentTime();
  52     void duration();
  53     void frameRate();
  54     void value();
  55     void currentFrame();
  56     void loopCount();
  57     void interpolation();
  58     void reverse_data();
  59     void reverse();
  60     void toggleDirection();
  61     void frameChanged();
  62     void stopped();
  63     void finished();
  64     void isRunning();
  65     void multipleTimeLines();
  66     void sineCurve();
  67     void cosineCurve();
  68     void outOfRange();
  69     void stateInFinishedSignal();
  70     void resume();
  71     void restart();
  72
  73 protected slots:
  74     void finishedSlot();
  75
  76 protected:
  77     QTimeLine::State state;
  78     QTimeLine * view;
  79 };
  80
  81 void tst_QTimeLine::range()
  82 {
  83 #ifdef Q_OS_WINCE //On WinCE timer resolution is bad - using longer times instead
  84     QTimeLine timeLine(2000);
  85 #else
  86     QTimeLine timeLine(200);
  87 #endif
  88     QCOMPARE(timeLine.startFrame(), 0);
  89     QCOMPARE(timeLine.endFrame(), 0);
  90     timeLine.setFrameRange(0, 1);
  91     QCOMPARE(timeLine.startFrame(), 0);
  92     QCOMPARE(timeLine.endFrame(), 1);
  93     timeLine.setFrameRange(10, 20);
  94     QCOMPARE(timeLine.startFrame(), 10);
  95     QCOMPARE(timeLine.endFrame(), 20);
  96
  97     timeLine.setStartFrame(6);
  98     QCOMPARE(timeLine.startFrame(), 6);
  99     timeLine.setEndFrame(16);
 100     QCOMPARE(timeLine.endFrame(), 16);
 101
 102     // Verify that you can change the range in the timeLine
 103     timeLine.setFrameRange(10, 20);
 104     QSignalSpy spy(&timeLine, SIGNAL(frameChanged(int)));
 105     QVERIFY(spy.isValid());
 106     timeLine.start();
 107 #ifdef Q_OS_WINCE
 108     QTest::qWait(1000);
 109 #else
 110     QTest::qWait(100);
 111 #endif
 112     QCOMPARE(timeLine.state(), QTimeLine::Running);
 113     int oldValue = timeLine.currentFrame();
 114     timeLine.setFrameRange(0, 5);
 115     QVERIFY(timeLine.currentFrame() < oldValue);
 116     timeLine.setEndFrame(100);
 117     timeLine.setStartFrame(50);
 118     QVERIFY(timeLine.currentFrame() > oldValue);
 119     timeLine.setFrameRange(0, 5);
 120 #ifdef Q_OS_WINCE
 121     QTest::qWait(500);
 122 #else
 123     QTest::qWait(50);
 124 #endif
 125     QVERIFY(spy.count() > 1);
 126     QVERIFY(timeLine.currentFrame() < oldValue);
 127 }
 128
 129 void tst_QTimeLine::currentTime()
 130 {
 131     QTimeLine timeLine(2000);
 132     timeLine.setUpdateInterval((timeLine.duration()/2) / 33);
 133     qRegisterMetaType<qreal>("qreal");
 134     QSignalSpy spy(&timeLine, SIGNAL(valueChanged(qreal)));
 135     QVERIFY(spy.isValid());
 136     timeLine.setFrameRange(10, 20);
 137     QCOMPARE(timeLine.currentTime(), 0);
 138     timeLine.start();
 139     QTest::qWait(timeLine.duration()/2);
 140     QCOMPARE(timeLine.state(), QTimeLine::Running);
 141     QVERIFY(timeLine.currentTime() > timeLine.duration()/2 - timeLine.duration()/10);
 142     QVERIFY(timeLine.currentTime() < timeLine.duration()/2 + timeLine.duration()/10);
 143     QTest::qWait(timeLine.duration()/4 + timeLine.duration());
 144     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 145     QCOMPARE(timeLine.currentTime(), timeLine.duration());
 146
 147     spy.clear();
 148     timeLine.setCurrentTime(timeLine.duration()/2);
 149     timeLine.setCurrentTime(timeLine.duration()/2);
 150     QCOMPARE(spy.count(), 1);
 151     spy.clear();
 152     QCOMPARE(timeLine.currentTime(), timeLine.duration()/2);
 153     timeLine.resume();
 154     // Let it update on its own
 155     QTest::qWait(timeLine.duration()/4);
 156     QCOMPARE(timeLine.state(), QTimeLine::Running);
 157     QVERIFY(timeLine.currentTime() > timeLine.duration()/2);
 158     QVERIFY(timeLine.currentTime() < timeLine.duration());
 159     QTest::qWait(timeLine.duration()/4 + timeLine.duration());
 160     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 161     QVERIFY(timeLine.currentTime() == timeLine.duration());
 162
 163     // Reverse should decrease the currentTime
 164     timeLine.setCurrentTime(timeLine.duration()/2);
 165     timeLine.start();
 166     // Let it update on its own
 167     QTest::qWait(timeLine.duration()/4);
 168     QCOMPARE(timeLine.state(), QTimeLine::Running);
 169     int currentTime = timeLine.currentTime();
 170     timeLine.setDirection(QTimeLine::Backward);
 171     QTest::qWait(timeLine.duration()/4);
 172     QVERIFY(timeLine.currentTime() < currentTime);
 173     timeLine.stop();
 174 }
 175
 176 void tst_QTimeLine::duration()
 177 {
 178     QTimeLine timeLine(200);
 179     timeLine.setFrameRange(10, 20);
 180     QCOMPARE(timeLine.duration(), 200);
 181     timeLine.setDuration(1000);
 182     QCOMPARE(timeLine.duration(), 1000);
 183
 184     timeLine.start();
 185     QTest::qWait(999);
 186     QCOMPARE(timeLine.state(), QTimeLine::Running);
 187     QVERIFY(timeLine.currentTime() > 0.9);
 188     QTest::qWait(50);
 189     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 190     // The duration shouldn't change
 191     QCOMPARE(timeLine.duration(), 1000);
 192 }
 193
 194 void tst_QTimeLine::frameRate()
 195 {
 196     QTimeLine timeLine;
 197     timeLine.setFrameRange(10, 20);
 198     QCOMPARE(timeLine.updateInterval(), 1000 / 25);
 199     timeLine.setUpdateInterval(1000 / 60);
 200     QCOMPARE(timeLine.updateInterval(), 1000 / 60);
 201
 202     // Default speed
 203     timeLine.setUpdateInterval(1000 / 33);
 204     QSignalSpy spy(&timeLine, SIGNAL(frameChanged(int)));
 205     QVERIFY(spy.isValid());
 206     timeLine.start();
 207     QTest::qWait(timeLine.duration()*2);
 208     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 209     int slowCount = spy.count();
 210
 211     // Faster!!
 212     timeLine.setUpdateInterval(1000 / 100);
 213     spy.clear();
 214     timeLine.setCurrentTime(0);
 215     timeLine.start();
 216     QTest::qWait(timeLine.duration()*2);
 217     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 218     QVERIFY(slowCount < spy.count());
 219 }
 220
 221 void tst_QTimeLine::value()
 222 {
 223     QTimeLine timeLine(2000);
 224     QVERIFY(timeLine.currentValue() == 0.0);
 225
 226     // Default speed
 227     qRegisterMetaType<qreal>("qreal");
 228     QSignalSpy spy(&timeLine, SIGNAL(valueChanged(qreal)));
 229     QVERIFY(spy.isValid());
 230     timeLine.start();
 231     QTest::qWait(timeLine.duration()/3);
 232     QVERIFY(timeLine.currentValue() > 0);
 233     QTest::qWait(timeLine.duration());
 234     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 235     qreal currentValue = timeLine.currentValue();
 236     QVERIFY(currentValue == 1);
 237     QVERIFY(spy.count() > 0);
 238
 239     // Reverse should decrease the value
 240     timeLine.setCurrentTime(100);
 241     timeLine.start();
 242     // Let it update on its own
 243     QTest::qWait(500);
 244     QCOMPARE(timeLine.state(), QTimeLine::Running);
 245     qreal value = timeLine.currentValue();
 246     timeLine.setDirection(QTimeLine::Backward);
 247     QTest::qWait(1000);
 248     QVERIFY(timeLine.currentValue() < value);
 249     timeLine.stop();
 250 }
 251
 252 void tst_QTimeLine::currentFrame()
 253 {
 254     QTimeLine timeLine(2000);
 255     timeLine.setFrameRange(10, 20);
 256     QCOMPARE(timeLine.currentFrame(), 10);
 257
 258     // Default speed
 259     QSignalSpy spy(&timeLine, SIGNAL(frameChanged(int)));
 260     QVERIFY(spy.isValid());
 261     timeLine.start();
 262     QTest::qWait(timeLine.duration()/3);
 263     QVERIFY(timeLine.currentFrame() > 10);
 264     QTest::qWait(timeLine.duration());
 265     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 266     QCOMPARE(timeLine.currentFrame(), 20);
 267
 268     // Reverse should decrease the value
 269     timeLine.setCurrentTime(timeLine.duration()/2);
 270     timeLine.start();
 271     // Let it update on its own
 272     QTest::qWait(timeLine.duration()/4);
 273     QCOMPARE(timeLine.state(), QTimeLine::Running);
 274     int value = timeLine.currentFrame();
 275     timeLine.setDirection(QTimeLine::Backward);
 276     QTest::qWait(timeLine.duration()/2);
 277     QVERIFY(timeLine.currentFrame() < value);
 278     timeLine.stop();
 279 }
 280
 281 void tst_QTimeLine::loopCount()
 282 {
 283     QTimeLine timeLine(200);
 284     QCOMPARE(timeLine.loopCount(), 1);
 285     timeLine.setFrameRange(10, 20);
 286     QCOMPARE(timeLine.loopCount(), 1);
 287     timeLine.setLoopCount(0);
 288     QCOMPARE(timeLine.loopCount(), 0);
 289
 290     // Default speed infiniti looping
 291     QSignalSpy spy(&timeLine, SIGNAL(frameChanged(int)));
 292     QVERIFY(spy.isValid());
 293     timeLine.start();
 294     QTest::qWait(timeLine.duration());
 295     QCOMPARE(timeLine.state(), QTimeLine::Running);
 296     //QCOMPARE(timeLine.currentFrame(), 20);
 297     QTest::qWait(timeLine.duration()*6);
 298     QCOMPARE(timeLine.state(), QTimeLine::Running);
 299     QVERIFY(timeLine.currentTime() >= 0);
 300     QVERIFY(timeLine.currentFrame() >= 10);
 301     QVERIFY(timeLine.currentFrame() <= 20);
 302     QCOMPARE(timeLine.state(), QTimeLine::Running);
 303     timeLine.stop();
 304
 305     timeLine.setDuration(2500); // ### some platforms have a very low resolution timer
 306     timeLine.setFrameRange(0, 2);
 307     timeLine.setLoopCount(4);
 308
 309     QSignalSpy finishedSpy(&timeLine, SIGNAL(finished()));
 310     QSignalSpy frameChangedSpy(&timeLine, SIGNAL(frameChanged(int)));
 311     QVERIFY(finishedSpy.isValid());
 312     QVERIFY(frameChangedSpy.isValid());
 313     QEventLoop loop;
 314     connect(&timeLine, SIGNAL(finished()), &loop, SLOT(quit()));
 315
 316
 317     for(int i=0;i<2;i++) {
 318
 319         timeLine.start();
 320         //we clear te list after the start so we don't catch
 321         //a frameChanged signal for the frame 0 at the beginning
 322         finishedSpy.clear();
 323         frameChangedSpy.clear();
 324
 325         loop.exec();
 326
 327         QCOMPARE(finishedSpy.count(), 1);
 328         QCOMPARE(frameChangedSpy.count(), 11);
 329         for (int i = 0; i < 11; ++i) {
 330             QCOMPARE(frameChangedSpy.at(i).at(0).toInt(), (i+1) % 3);
 331         }
 332     }
 333
 334     timeLine.setDirection(QTimeLine::Backward);
 335     timeLine.start();
 336     loop.exec();
 337
 338     QCOMPARE(finishedSpy.count(), 2);
 339     QCOMPARE(frameChangedSpy.count(), 22);
 340     for (int i = 11; i < 22; ++i) {
 341         QCOMPARE(frameChangedSpy.at(i).at(0).toInt(), 2 - (i+2) % 3);
 342     }
 343 }
 344
 345 void tst_QTimeLine::interpolation()
 346 {
 347     QTimeLine timeLine(400);
 348     QCOMPARE(timeLine.curveShape(), QTimeLine::EaseInOutCurve);
 349     timeLine.setFrameRange(100, 200);
 350     timeLine.setCurveShape(QTimeLine::LinearCurve);
 351     QCOMPARE(timeLine.curveShape(), QTimeLine::LinearCurve);
 352
 353     // smooth
 354     timeLine.setCurveShape(QTimeLine::EaseInOutCurve);
 355     timeLine.start();
 356     QTest::qWait(100);
 357     QCOMPARE(timeLine.state(), QTimeLine::Running);
 358     int firstValue = timeLine.currentFrame();
 359     QTest::qWait(200);
 360     int endValue = timeLine.currentFrame();
 361     timeLine.stop();
 362     timeLine.setCurrentTime(0);
 363
 364     // linear
 365     timeLine.setCurveShape(QTimeLine::LinearCurve);
 366     timeLine.start();
 367     QTest::qWait(100);
 368     QCOMPARE(timeLine.state(), QTimeLine::Running);
 369
 370     // Smooth accellerates slowly so in the beginning so it is farther behind
 371     QVERIFY(firstValue < timeLine.currentFrame());
 372     QTest::qWait(200);
 373     QVERIFY(endValue > timeLine.currentFrame());
 374     timeLine.stop();
 375 }
 376
 377 void tst_QTimeLine::reverse_data()
 378 {
 379     QTest::addColumn<int>("duration");
 380     QTest::addColumn<int>("start");
 381     QTest::addColumn<int>("end");
 382     QTest::addColumn<int>("direction");
 383     QTest::addColumn<int>("direction2");
 384     QTest::addColumn<int>("direction3");
 385     QTest::addColumn<int>("startTime");
 386     QTest::addColumn<int>("currentFrame");
 387     QTest::addColumn<qreal>("currentValue");
 388     QTest::addColumn<int>("wait");
 389     QTest::addColumn<int>("state");
 390     QTest::addColumn<int>("wait2");
 391
 392     QTest::newRow("start at end") << 200 << 1000 << 2000 << (int)QTimeLine::Backward << (int)QTimeLine::Forward << (int)QTimeLine::Backward << 200 << 2000 << qreal(1.0) << 40 << (int)QTimeLine::Running << 140;
 393     QTest::newRow("start at half") << 200 << 1000 << 2000 << (int)QTimeLine::Backward << (int)QTimeLine::Forward << (int)QTimeLine::Backward << 100 << 1500 << qreal(0.5) << 40 << (int)QTimeLine::Running << 140;
 394     QTest::newRow("start at quarter") << 200 << 1000 << 2000 << (int)QTimeLine::Backward << (int)QTimeLine::Forward << (int)QTimeLine::Backward << 50 << 1250 << qreal(0.25) << 40 << (int)QTimeLine::Running << 140;
 395 }
 396
 397 void tst_QTimeLine::reverse()
 398 {
 399     QFETCH(int, duration);
 400     QFETCH(int, start);
 401     QFETCH(int, end);
 402     QFETCH(int, direction);
 403     QFETCH(int, direction2);
 404     QFETCH(int, direction3);
 405     QFETCH(int, startTime);
 406     QFETCH(int, currentFrame);
 407     QFETCH(qreal, currentValue);
 408     QFETCH(int, wait);
 409     QFETCH(int, state);
 410     QFETCH(int, wait2);
 411
 412     QTimeLine timeLine(duration);
 413     timeLine.setCurveShape(QTimeLine::LinearCurve);
 414     timeLine.setFrameRange(start, end);
 415
 416     timeLine.setDirection((QTimeLine::Direction)direction);
 417     timeLine.setDirection((QTimeLine::Direction)direction2);
 418     timeLine.setDirection((QTimeLine::Direction)direction3);
 419     QCOMPARE(timeLine.direction(), ((QTimeLine::Direction)direction));
 420
 421     timeLine.setCurrentTime(startTime);
 422     timeLine.setDirection((QTimeLine::Direction)direction);
 423     timeLine.setDirection((QTimeLine::Direction)direction2);
 424     timeLine.setDirection((QTimeLine::Direction)direction3);
 425
 426     QCOMPARE(timeLine.currentFrame(), currentFrame);
 427     QCOMPARE(timeLine.currentValue(), currentValue);
 428     timeLine.start();
 429
 430     QTest::qWait(wait);
 431     QCOMPARE(timeLine.state(), (QTimeLine::State)state);
 432     int firstValue = timeLine.currentFrame();
 433     timeLine.setDirection((QTimeLine::Direction)direction2);
 434     timeLine.setDirection((QTimeLine::Direction)direction3);
 435     timeLine.setDirection((QTimeLine::Direction)direction2);
 436     timeLine.setDirection((QTimeLine::Direction)direction3);
 437     QTest::qWait(wait2);
 438     int endValue = timeLine.currentFrame();
 439     QVERIFY(endValue < firstValue);
 440
 441
 442 }
 443
 444 void tst_QTimeLine::toggleDirection()
 445 {
 446     // Note: enum values are cast to int so that QCOMPARE will show
 447     // the values if they don't match.
 448     QTimeLine timeLine;
 449     QCOMPARE(int(timeLine.direction()), int(QTimeLine::Forward));
 450     timeLine.toggleDirection();
 451     QCOMPARE(int(timeLine.direction()), int(QTimeLine::Backward));
 452     timeLine.toggleDirection();
 453     QCOMPARE(int(timeLine.direction()), int(QTimeLine::Forward));
 454 }
 455
 456 void tst_QTimeLine::frameChanged()
 457 {
 458     QTimeLine timeLine;
 459     timeLine.setFrameRange(0,9);
 460     timeLine.setUpdateInterval(1000);
 461     QSignalSpy spy(&timeLine, SIGNAL(frameChanged(int)));
 462     QVERIFY(spy.isValid());
 463     timeLine.start();
 464     QTest::qWait(timeLine.duration()*2);
 465     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 466     // Probably 10
 467     QVERIFY(spy.count() <= 10 && spy.count() > 0);
 468
 469     timeLine.setUpdateInterval(5);
 470     spy.clear();
 471     timeLine.setCurrentTime(0);
 472     timeLine.start();
 473     QTest::qWait(timeLine.duration()*2);
 474     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 475     // Probably 1
 476     QVERIFY(spy.count() <= 10 && spy.count() > 0);
 477 }
 478
 479 void tst_QTimeLine::stopped()
 480 {
 481     QTimeLine timeLine;
 482     timeLine.setFrameRange(0, 9);
 483     qRegisterMetaType<QTimeLine::State>("QTimeLine::State");
 484     QSignalSpy spy(&timeLine, SIGNAL(stateChanged(QTimeLine::State)));
 485     QVERIFY(spy.isValid());
 486     timeLine.start();
 487     QTest::qWait(timeLine.duration()*2);
 488     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 489     QCOMPARE(spy.count(), 2);
 490     spy.clear();
 491     timeLine.start();
 492     timeLine.stop();
 493     QCOMPARE(spy.count(), 2);
 494     timeLine.setDirection(QTimeLine::Backward);
 495     QCOMPARE(timeLine.loopCount(), 1);
 496 }
 497
 498 void tst_QTimeLine::finished()
 499 {
 500     QTimeLine timeLine;
 501     timeLine.setFrameRange(0,9);
 502     QSignalSpy spy(&timeLine, SIGNAL(finished()));
 503     QVERIFY(spy.isValid());
 504     timeLine.start();
 505     QTest::qWait(timeLine.duration()*2);
 506     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 507     QCOMPARE(spy.count(), 1);
 508
 509     spy.clear();
 510     timeLine.start();
 511     timeLine.stop();
 512     QCOMPARE(spy.count(), 0);
 513 }
 514
 515 void tst_QTimeLine::isRunning()
 516 {
 517     QTimeLine timeLine;
 518     timeLine.setFrameRange(0,9);
 519     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 520     timeLine.start();
 521     QCOMPARE(timeLine.state(), QTimeLine::Running);
 522     timeLine.stop();
 523     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 524
 525     timeLine.start();
 526     QTest::qWait(timeLine.duration()*2);
 527     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 528 }
 529
 530 void tst_QTimeLine::multipleTimeLines()
 531 {
 532     // Stopping a timer shouldn't affect the other timers
 533     QTimeLine timeLine(200);
 534     timeLine.setFrameRange(0,99);
 535     QSignalSpy spy(&timeLine, SIGNAL(finished()));
 536     QVERIFY(spy.isValid());
 537
 538     QTimeLine timeLineKiller;
 539     timeLineKiller.setFrameRange(0,99);
 540
 541     timeLineKiller.start();
 542     timeLine.start();
 543     timeLineKiller.stop();
 544     QTest::qWait(timeLine.duration()*2);
 545     QCOMPARE(spy.count(), 1);
 546 }
 547
 548 void tst_QTimeLine::sineCurve()
 549 {
 550     QTimeLine timeLine(1000);
 551     timeLine.setCurveShape(QTimeLine::SineCurve);
 552     QCOMPARE(timeLine.valueForTime(0), qreal(0));
 553     QCOMPARE(timeLine.valueForTime(250), qreal(0.5));
 554     QCOMPARE(timeLine.valueForTime(500), qreal(1));
 555     QCOMPARE(timeLine.valueForTime(750), qreal(0.5));
 556     QCOMPARE(timeLine.valueForTime(1000), qreal(0));
 557 }
 558
 559 void tst_QTimeLine::cosineCurve()
 560 {
 561     QTimeLine timeLine(1000);
 562     timeLine.setCurveShape(QTimeLine::CosineCurve);
 563     QCOMPARE(timeLine.valueForTime(0), qreal(0.5));
 564     QCOMPARE(timeLine.valueForTime(250), qreal(1));
 565     QCOMPARE(timeLine.valueForTime(500), qreal(0.5));
 566     QCOMPARE(timeLine.valueForTime(750), qreal(0));
 567     QCOMPARE(timeLine.valueForTime(1000), qreal(0.5));
 568 }
 569
 570 void tst_QTimeLine::outOfRange()
 571 {
 572     QTimeLine timeLine(1000);
 573     QCOMPARE(timeLine.valueForTime(-100), qreal(0));
 574     QCOMPARE(timeLine.valueForTime(2000), qreal(1));
 575
 576     timeLine.setCurveShape(QTimeLine::SineCurve);
 577     QCOMPARE(timeLine.valueForTime(2000), qreal(0));
 578 }
 579
 580 void tst_QTimeLine::stateInFinishedSignal()
 581 {
 582     QTimeLine timeLine(50);
 583
 584     connect(&timeLine, SIGNAL(finished()), this, SLOT(finishedSlot()));
 585     state = QTimeLine::State(-1);
 586
 587     timeLine.start();
 588     QTest::qWait(250);
 589
 590     QCOMPARE(state, QTimeLine::NotRunning);
 591 }
 592
 593 void tst_QTimeLine::finishedSlot()
 594 {
 595     QTimeLine *timeLine = qobject_cast<QTimeLine *>(sender());
 596     if (timeLine)
 597         state = timeLine->state();
 598 }
 599
 600 void tst_QTimeLine::resume()
 601 {
 602     QTimeLine timeLine(1000);
 603     {
 604         QCOMPARE(timeLine.currentTime(), 0);
 605         timeLine.start();
 606         QTest::qWait(250);
 607         timeLine.stop();
 608         int oldCurrentTime = timeLine.currentTime();
 609         QVERIFY(oldCurrentTime > 0);
 610         QVERIFY(oldCurrentTime < 1000);
 611         timeLine.resume();
 612         QTest::qWait(250);
 613         timeLine.stop();
 614         int currentTime = timeLine.currentTime();
 615         QVERIFY(currentTime > oldCurrentTime);
 616         QVERIFY(currentTime < 1000);
 617     }
 618     timeLine.setDirection(QTimeLine::Backward);
 619     {
 620         timeLine.setCurrentTime(1000);
 621         QCOMPARE(timeLine.currentTime(), 1000);
 622         timeLine.start();
 623         QTest::qWait(250);
 624         timeLine.stop();
 625         int oldCurrentTime = timeLine.currentTime();
 626         QVERIFY(oldCurrentTime < 1000);
 627         QVERIFY(oldCurrentTime > 0);
 628         timeLine.resume();
 629         QTest::qWait(250);
 630         timeLine.stop();
 631         int currentTime = timeLine.currentTime();
 632         QVERIFY(currentTime < oldCurrentTime);
 633         QVERIFY(currentTime > 0);
 634     }
 635 }
 636
 637 void tst_QTimeLine::restart()
 638 {
 639     QTimeLine timeLine(100);
 640     timeLine.setFrameRange(0,9);
 641
 642     timeLine.start();
 643     QTest::qWait(timeLine.duration()*2);
 644     QCOMPARE(timeLine.currentFrame(), timeLine.endFrame());
 645     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 646
 647     // A restart with the same duration
 648     timeLine.start();
 649     QCOMPARE(timeLine.state(), QTimeLine::Running);
 650     QCOMPARE(timeLine.currentFrame(), timeLine.startFrame());
 651     QCOMPARE(timeLine.currentTime(), 0);
 652     QTest::qWait(250);
 653     QCOMPARE(timeLine.currentFrame(), timeLine.endFrame());
 654     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 655
 656     // Set a smaller duration and restart
 657     timeLine.setDuration(50);
 658     timeLine.start();
 659     QCOMPARE(timeLine.state(), QTimeLine::Running);
 660     QCOMPARE(timeLine.currentFrame(), timeLine.startFrame());
 661     QCOMPARE(timeLine.currentTime(), 0);
 662     QTest::qWait(250);
 663     QCOMPARE(timeLine.currentFrame(), timeLine.endFrame());
 664     QCOMPARE(timeLine.state(), QTimeLine::NotRunning);
 665
 666     // Set a longer duration and restart
 667     timeLine.setDuration(150);
 668     timeLine.start();
 669     QCOMPARE(timeLine.state(), QTimeLine::Running);
 670     QCOMPARE(timeLine.currentFrame(), timeLine.startFrame());
 671     QCOMPARE(timeLine.currentTime(), 0);
 672 }
 673
 674 QTEST_MAIN(tst_QTimeLine)
 675
 676 #include "tst_qtimeline.moc"