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