1 /*
2 * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package test.javafx.animation;
27
28 import com.sun.javafx.animation.TickCalculation;
29 import javafx.animation.Animation.Status;
30 import javafx.animation.Interpolator;
31 import javafx.animation.ParallelTransition;
32 import javafx.animation.ParallelTransitionShim;
33 import javafx.animation.Transition;
34 import javafx.animation.TransitionShim;
35 import javafx.beans.property.LongProperty;
36 import javafx.beans.property.SimpleLongProperty;
37 import javafx.util.Duration;
38 import static org.junit.Assert.assertEquals;
39 import org.junit.Before;
40 import org.junit.Test;
41
42 public class ParallelTransitionPlayTest {
43 public static final double TICK_MILLIS = TickCalculation.toMillis(100);
44 public static final long TICK_STEP = Math.round(TICK_MILLIS);
45
46 LongProperty xProperty = new SimpleLongProperty();
47 LongProperty yProperty = new SimpleLongProperty();
48
49 AbstractMasterTimerMock amt;
50 ParallelTransition pt;
51
52 Transition child1X;
53 Transition child2X;
54 Transition child1Y;
55 Transition childByX;
56
57 @Before
58 public void setUp() {
59 amt = new AbstractMasterTimerMock();
60 pt = ParallelTransitionShim.getParallelTransition(amt);
61 child1X = new TransitionShim() {
62
63 {
64 setCycleDuration(Duration.minutes(1));
65 setInterpolator(Interpolator.LINEAR);
66 }
67
68 @Override
69 protected void interpolate(double d) {
70 xProperty.set(Math.round(d * 60000));
71 }
72 };
73 child1Y = new TransitionShim() {
74
75 {
76 setCycleDuration(Duration.seconds(10));
77 setInterpolator(Interpolator.LINEAR);
78 }
79
80 @Override
81 protected void interpolate(double d) {
82 yProperty.set(Math.round(d * 10000));
83 }
84 };
85 childByX = new TransitionShim() {
86 {
87 setCycleDuration(Duration.seconds(1));
88 setInterpolator(Interpolator.LINEAR);
89 }
90
91 long lastX;
92
93 @Override
94 protected void interpolate(double frac) {
95 xProperty.set(Math.round(lastX + frac * 1000));
96 }
97
98 @Override
99 public void sync(boolean forceSync) {
100 super.sync(forceSync);
101 if (forceSync) {
102 lastX = xProperty.get();
103 }
104 }
105
106
107 };
108 }
109
110
111 @Test
112 public void testSimplePlay() {
113 pt.getChildren().addAll(child1X, child1Y);
114
115 pt.play();
116 assertEquals(Status.RUNNING, pt.getStatus());
117 assertEquals(Status.STOPPED, child1X.getStatus());
118 assertEquals(Status.STOPPED, child1Y.getStatus());
119
120 amt.pulse();
121 assertEquals(TickCalculation.toDuration(100), pt.getCurrentTime());
122 assertEquals(TickCalculation.toDuration(100), child1X.getCurrentTime());
123 assertEquals(TickCalculation.toDuration(100), child1Y.getCurrentTime());
124 assertEquals(TICK_STEP, xProperty.get());
125 assertEquals(TICK_STEP, yProperty.get());
126
127 assertEquals(Status.RUNNING, pt.getStatus());
128 assertEquals(Status.RUNNING, child1X.getStatus());
129 assertEquals(Status.RUNNING, child1Y.getStatus());
130
131 pt.jumpTo(Duration.seconds(10).subtract(TickCalculation.toDuration(100)));
132
133 assertEquals(Status.RUNNING, pt.getStatus());
134 assertEquals(Status.RUNNING, child1X.getStatus());
135 assertEquals(Status.RUNNING, child1Y.getStatus());
136 assertEquals(10000 - TICK_STEP, xProperty.get());
137 assertEquals(10000 - TICK_STEP, yProperty.get());
138
139 amt.pulse();
140
141 assertEquals(Status.RUNNING, pt.getStatus());
142 assertEquals(Status.RUNNING, child1X.getStatus());
143 assertEquals(Status.STOPPED, child1Y.getStatus());
144 assertEquals(10000, xProperty.get());
145 assertEquals(10000, yProperty.get());
146
147 amt.pulse();
148
149 assertEquals(Status.RUNNING, pt.getStatus());
150 assertEquals(Status.RUNNING, child1X.getStatus());
151 assertEquals(Status.STOPPED, child1Y.getStatus());
152 assertEquals(10000 + TICK_STEP, xProperty.get());
153 assertEquals(10000, yProperty.get());
154
155 pt.jumpTo(Duration.minutes(1).subtract(TickCalculation.toDuration(100)));
156
157 assertEquals(Status.RUNNING, pt.getStatus());
158 assertEquals(Status.RUNNING, child1X.getStatus());
159 assertEquals(Status.STOPPED, child1Y.getStatus());
160 assertEquals(60000 - TICK_STEP, xProperty.get());
161 assertEquals(10000, yProperty.get());
162
163 amt.pulse();
164 assertEquals(Status.STOPPED, pt.getStatus());
165 assertEquals(Status.STOPPED, child1X.getStatus());
166 assertEquals(Status.STOPPED, child1Y.getStatus());
167 assertEquals(60000, xProperty.get());
168 assertEquals(10000, yProperty.get());
169 }
170
171 @Test
172 public void testSimplePlayReversed() {
173 pt.getChildren().addAll(child1X, child1Y);
174
175 pt.setRate(-1.0);
176 pt.jumpTo(Duration.seconds(60));
177
178 pt.play();
179 assertEquals(Status.RUNNING, pt.getStatus());
180 assertEquals(Status.STOPPED, child1X.getStatus());
181 assertEquals(Status.STOPPED, child1Y.getStatus());
182
183 amt.pulse();
184 assertEquals(60000 - TICK_STEP, xProperty.get());
185 assertEquals(10000, yProperty.get());
186
187 assertEquals(Status.RUNNING, pt.getStatus());
188 assertEquals(Status.RUNNING, child1X.getStatus());
189 assertEquals(Status.STOPPED, child1Y.getStatus());
190
191 pt.jumpTo(Duration.seconds(10).add(TickCalculation.toDuration(100)));
192
193 assertEquals(Status.RUNNING, pt.getStatus());
194 assertEquals(Status.RUNNING, child1X.getStatus());
195 assertEquals(Status.STOPPED, child1Y.getStatus());
196 assertEquals(10000 + TICK_STEP, xProperty.get());
197 assertEquals(10000, yProperty.get());
198
199 amt.pulse();
200
201 assertEquals(Status.RUNNING, pt.getStatus());
202 assertEquals(Status.RUNNING, child1X.getStatus());
203 assertEquals(Status.STOPPED, child1Y.getStatus());
204 assertEquals(10000, xProperty.get());
205 assertEquals(10000, yProperty.get());
206
207 amt.pulse();
208
209 assertEquals(Status.RUNNING, pt.getStatus());
210 assertEquals(Status.RUNNING, child1X.getStatus());
211 assertEquals(Status.RUNNING, child1Y.getStatus());
212 assertEquals(10000 - TICK_STEP, xProperty.get());
213 assertEquals(10000 - TICK_STEP, yProperty.get());
214
215 pt.jumpTo(TickCalculation.toDuration(100));
216
217 assertEquals(Status.RUNNING, pt.getStatus());
218 assertEquals(Status.RUNNING, child1X.getStatus());
219 assertEquals(Status.RUNNING, child1Y.getStatus());
220 assertEquals(TICK_STEP, xProperty.get());
221 assertEquals(TICK_STEP, yProperty.get());
222
223 amt.pulse();
224 assertEquals(Status.STOPPED, pt.getStatus());
225 assertEquals(Status.STOPPED, child1X.getStatus());
226 assertEquals(Status.STOPPED, child1Y.getStatus());
227 assertEquals(0, xProperty.get());
228 assertEquals(0, yProperty.get());
229 }
230
231 @Test
232 public void testCycle() {
233 pt.getChildren().addAll(child1X, child1Y);
234 pt.setCycleCount(2);
235
236 pt.play();
237
238 pt.jumpTo(Duration.minutes(1).subtract(TickCalculation.toDuration(100)));
239
240 assertEquals(Status.RUNNING, pt.getStatus());
241 assertEquals(Status.RUNNING, child1X.getStatus());
242 assertEquals(Status.STOPPED, child1Y.getStatus());
243 assertEquals(60000 - TICK_STEP, xProperty.get());
244 assertEquals(10000, yProperty.get());
245
246 amt.pulse();
247
248 assertEquals(Status.RUNNING, pt.getStatus());
249 assertEquals(Status.STOPPED, child1X.getStatus());
250 assertEquals(Status.STOPPED, child1Y.getStatus());
251 assertEquals(0, xProperty.get());
252 assertEquals(0, yProperty.get());
253
254 pt.jumpTo(Duration.seconds(65).subtract(TickCalculation.toDuration(100)));
255
256 assertEquals(Status.RUNNING, pt.getStatus());
257 assertEquals(Status.RUNNING, child1X.getStatus());
258 assertEquals(Status.RUNNING, child1Y.getStatus());
259 assertEquals(5000 - TICK_STEP, xProperty.get());
260 assertEquals(5000 - TICK_STEP, yProperty.get());
261
262 amt.pulse();
263 assertEquals(Status.RUNNING, pt.getStatus());
264 assertEquals(Status.RUNNING, child1X.getStatus());
265 assertEquals(Status.RUNNING, child1Y.getStatus());
266 assertEquals(5000, xProperty.get());
267 assertEquals(5000, yProperty.get());
268
269 pt.jumpTo(Duration.minutes(2).subtract(TickCalculation.toDuration(100)));
270
271 assertEquals(Status.RUNNING, pt.getStatus());
272 assertEquals(Status.RUNNING, child1X.getStatus());
273 assertEquals(Status.STOPPED, child1Y.getStatus());
274 assertEquals(60000 - TICK_STEP, xProperty.get());
275 assertEquals(10000, yProperty.get());
276
277 amt.pulse();
278 assertEquals(Status.STOPPED, pt.getStatus());
279 assertEquals(Status.STOPPED, child1X.getStatus());
280 assertEquals(Status.STOPPED, child1Y.getStatus());
281 assertEquals(60000, xProperty.get());
282 assertEquals(10000, yProperty.get());
283
284 }
285
286 @Test
287 public void testCycleReversed() {
288 pt.getChildren().addAll(child1X, child1Y);
289 pt.setCycleCount(2);
290 pt.setRate(-1.0);
291 pt.jumpTo(Duration.seconds(60));
292
293 pt.play();
294
295 assertEquals(Status.RUNNING, pt.getStatus());
296 assertEquals(Status.STOPPED, child1X.getStatus());
297 assertEquals(Status.STOPPED, child1Y.getStatus());
298 assertEquals(60000, xProperty.get());
299 assertEquals(10000, yProperty.get());
300
301 amt.pulse();
302
303 assertEquals(Status.RUNNING, pt.getStatus());
304 assertEquals(Status.RUNNING, child1X.getStatus());
305 assertEquals(Status.STOPPED, child1Y.getStatus());
306 assertEquals(60000 - TICK_STEP, xProperty.get());
307 assertEquals(10000, yProperty.get());
308
309 pt.jumpTo(Duration.seconds(60).add(TickCalculation.toDuration(100)));
310
311 assertEquals(Status.RUNNING, pt.getStatus());
312 assertEquals(Status.RUNNING, child1X.getStatus());
313 assertEquals(Status.RUNNING, child1Y.getStatus());
314 assertEquals(TICK_STEP, xProperty.get());
315 assertEquals(TICK_STEP, yProperty.get());
316
317 amt.pulse();
318 assertEquals(Status.RUNNING, pt.getStatus());
319 assertEquals(Status.STOPPED, child1X.getStatus());
320 assertEquals(Status.STOPPED, child1Y.getStatus());
321 assertEquals(60000, xProperty.get());
322 assertEquals(10000, yProperty.get());
323
324 pt.jumpTo(Duration.minutes(2).subtract(TickCalculation.toDuration(100)));
325
326 assertEquals(Status.RUNNING, pt.getStatus());
327 assertEquals(Status.RUNNING, child1X.getStatus());
328 assertEquals(Status.STOPPED, child1Y.getStatus());
329 assertEquals(60000 - TICK_STEP, xProperty.get());
330 assertEquals(10000, yProperty.get());
331
332 amt.pulse();
333 assertEquals(Status.RUNNING, pt.getStatus());
334 assertEquals(Status.RUNNING, child1X.getStatus());
335 assertEquals(Status.STOPPED, child1Y.getStatus());
336 assertEquals(60000 - Math.round(2 * TICK_MILLIS), xProperty.get());
337 assertEquals(10000, yProperty.get());
338
339 }
340
341 @Test
342 public void testAutoReverse() {
343 pt.getChildren().addAll(child1X, child1Y);
344 pt.setAutoReverse(true);
345 pt.setCycleCount(-1);
346
347 pt.play();
348
349 for (int i = 0; i < TickCalculation.fromDuration(Duration.seconds(60)) / 100 - 1; ++i) {
350 amt.pulse();
351 }
352
353 amt.pulse();
354
355 assertEquals(Status.RUNNING, pt.getStatus());
356 assertEquals(Status.STOPPED, child1X.getStatus());
357 assertEquals(Status.STOPPED, child1Y.getStatus());
358
359 assertEquals(60000, xProperty.get());
360 assertEquals(10000, yProperty.get());
361
362 amt.pulse();
363
364 assertEquals(Status.RUNNING, pt.getStatus());
365 assertEquals(Status.RUNNING, child1X.getStatus());
366 assertEquals(Status.STOPPED, child1Y.getStatus());
367
368 assertEquals(60000 - TICK_STEP, xProperty.get());
369 assertEquals(10000, yProperty.get());
370
371 }
372
373 @Test
374 public void testAutoReverseWithJump() {
375 pt.getChildren().addAll(child1X, child1Y);
376 pt.setAutoReverse(true);
377 pt.setCycleCount(-1);
378
379 pt.play();
380
381 pt.jumpTo(Duration.seconds(60).subtract(TickCalculation.toDuration(100)));
382
383 amt.pulse();
384
385 assertEquals(Status.RUNNING, pt.getStatus());
386 assertEquals(Status.STOPPED, child1X.getStatus());
387 assertEquals(Status.STOPPED, child1Y.getStatus());
388
389 assertEquals(60000, xProperty.get());
390 assertEquals(10000, yProperty.get());
391
392 amt.pulse();
393
394 assertEquals(Status.RUNNING, pt.getStatus());
395 assertEquals(Status.RUNNING, child1X.getStatus());
396 assertEquals(Status.STOPPED, child1Y.getStatus());
397
398 assertEquals(60000 - TICK_STEP, xProperty.get());
399 assertEquals(10000, yProperty.get());
400
401 }
402
403 @Test
404 public void testJump() {
405 pt.getChildren().addAll(child1X, child1Y);
406
407 assertEquals(Status.STOPPED, pt.getStatus());
408 assertEquals(Status.STOPPED, child1X.getStatus());
409 assertEquals(Status.STOPPED, child1Y.getStatus());
410 assertEquals(0, xProperty.get());
411 assertEquals(0, yProperty.get());
412
413 pt.jumpTo(Duration.seconds(10));
414
415 assertEquals(Status.STOPPED, pt.getStatus());
416 assertEquals(Status.STOPPED, child1X.getStatus());
417 assertEquals(Status.STOPPED, child1Y.getStatus());
418 assertEquals(0, xProperty.get());
419 assertEquals(0, yProperty.get());
420
421 pt.play();
422
423 assertEquals(Status.RUNNING, pt.getStatus());
424 assertEquals(Status.RUNNING, child1X.getStatus()); //Note: Not sure if we need to have also child1X running at this point
425 assertEquals(Status.STOPPED, child1Y.getStatus());
426 assertEquals(10000, xProperty.get());
427 assertEquals(10000, yProperty.get());
428
429 amt.pulse();
430
431 assertEquals(Status.RUNNING, pt.getStatus());
432 assertEquals(Status.RUNNING, child1X.getStatus());
433 assertEquals(Status.STOPPED, child1Y.getStatus());
434 assertEquals(10000 + TICK_STEP, xProperty.get());
435 assertEquals(10000, yProperty.get());
436
437 pt.jumpTo(Duration.seconds(55));
438
439 assertEquals(Status.RUNNING, pt.getStatus());
440 assertEquals(Status.RUNNING, child1X.getStatus());
441 assertEquals(Status.STOPPED, child1Y.getStatus());
442 assertEquals(55000, xProperty.get());
443 assertEquals(10000, yProperty.get());
444
445 pt.jumpTo(Duration.seconds(10));
446
447 assertEquals(Status.RUNNING, pt.getStatus());
448 assertEquals(Status.RUNNING, child1X.getStatus());
449 assertEquals(Status.STOPPED, child1Y.getStatus());
450 assertEquals(10000, xProperty.get());
451 assertEquals(10000, yProperty.get());
452
453 pt.stop();
454
455 assertEquals(Status.STOPPED, pt.getStatus());
456 assertEquals(Status.STOPPED, child1X.getStatus());
457 assertEquals(Status.STOPPED, child1Y.getStatus());
458 assertEquals(10000, xProperty.get());
459 assertEquals(10000, yProperty.get());
460
461 }
462
463 @Test
464 public void testToggleRate() {
465 pt.getChildren().addAll(child1X, child1Y);
466
467 pt.play();
468
469 pt.jumpTo(Duration.seconds(10));
470
471 amt.pulse();
472
473 assertEquals(Status.RUNNING, pt.getStatus());
474 assertEquals(Status.RUNNING, child1X.getStatus());
475 assertEquals(Status.STOPPED, child1Y.getStatus());
476
477 assertEquals(10000 + TICK_STEP, xProperty.get());
478 assertEquals(10000, yProperty.get());
479
480 pt.setRate(-1.0);
481
482 amt.pulse();
483 amt.pulse();
484
485 assertEquals(Status.RUNNING, pt.getStatus());
486 assertEquals(Status.RUNNING, child1X.getStatus());
487 assertEquals(Status.RUNNING, child1Y.getStatus());
488
489 assertEquals(10000 - TICK_STEP, xProperty.get());
490 assertEquals(10000 - TICK_STEP, yProperty.get());
491
492 pt.setRate(1.0);
493
494 amt.pulse();
495 amt.pulse();
496
497 assertEquals(Status.RUNNING, pt.getStatus());
498 assertEquals(Status.RUNNING, child1X.getStatus());
499 assertEquals(Status.STOPPED, child1Y.getStatus());
500
501 assertEquals(10000 + TICK_STEP, xProperty.get());
502 assertEquals(10000, yProperty.get());
503 }
504
505 @Test
506 public void testToggleRate_2() {
507 pt.getChildren().addAll(child1X, child1Y);
508
509 pt.play();
510
511 pt.jumpTo(Duration.seconds(20));
512
513 amt.pulse();
514
515 assertEquals(Status.RUNNING, pt.getStatus());
516 assertEquals(Status.RUNNING, child1X.getStatus());
517 assertEquals(Status.STOPPED, child1Y.getStatus());
518
519 assertEquals(20000 + TICK_STEP, xProperty.get());
520 assertEquals(10000, yProperty.get());
521
522 pt.setRate(-1.0);
523
524 amt.pulse();
525 amt.pulse();
526
527 assertEquals(Status.RUNNING, pt.getStatus());
528 assertEquals(Status.RUNNING, child1X.getStatus());
529 assertEquals(Status.STOPPED, child1Y.getStatus());
530
531 assertEquals(20000 - TICK_STEP, xProperty.get());
532 assertEquals(10000, yProperty.get());
533
534 pt.setRate(1.0);
535
536 amt.pulse();
537 amt.pulse();
538
539 assertEquals(Status.RUNNING, pt.getStatus());
540 assertEquals(Status.RUNNING, child1X.getStatus());
541 assertEquals(Status.STOPPED, child1Y.getStatus());
542
543 assertEquals(20000 + TICK_STEP, xProperty.get());
544 assertEquals(10000, yProperty.get());
545 }
546
547
548 @Test
549 public void testChildWithDifferentRate() {
550 pt.getChildren().addAll(child1X, child1Y);
551 child1X.setRate(2.0);
552
553 pt.play();
554
555 amt.pulse();
556
557 assertEquals(Math.round(TICK_MILLIS * 2), xProperty.get());
558
559 pt.jumpTo(Duration.seconds(30));
560
561 assertEquals(60000, xProperty.get());
562 assertEquals(10000, yProperty.get());
563
564 pt.jumpTo(Duration.seconds(40));
565
566 assertEquals(60000, xProperty.get());
567 assertEquals(10000, yProperty.get());
568
569 pt.jumpTo(Duration.seconds(5));
570 amt.pulse();
571
572 pt.setRate(-1.0);
573
574 amt.pulse();
575 amt.pulse();
576
577 assertEquals(10000 - Math.round(TICK_MILLIS * 2), xProperty.get());
578 assertEquals(5000 - TICK_STEP, yProperty.get());
579
580 pt.setRate(1.0);
581
582 amt.pulse();
583 amt.pulse();
584
585 assertEquals(10000 + Math.round(TICK_MILLIS * 2), xProperty.get());
586 assertEquals(5000 + TICK_STEP, yProperty.get());
587
588 }
589
590 @Test
591 public void testPauseForward1() {
592 pt.getChildren().addAll(child1X, child1Y);
593
594 pt.play();
595 pt.jumpTo(Duration.seconds(5));
596 amt.pulse();
597 pt.pause();
598 assertEquals(Status.PAUSED, pt.getStatus());
599 assertEquals(Status.PAUSED, child1X.getStatus());
600 assertEquals(Status.PAUSED, child1Y.getStatus());
601 assertEquals(5000 + TICK_STEP, xProperty.get());
602 assertEquals(5000 + TICK_STEP, yProperty.get());
603
604 pt.jumpTo(Duration.seconds(6));
605 assertEquals(Status.PAUSED, pt.getStatus());
606 assertEquals(Status.PAUSED, child1X.getStatus());
607 assertEquals(Status.PAUSED, child1Y.getStatus());
608 assertEquals(6000, xProperty.get());
609 assertEquals(6000, yProperty.get());
610
611 pt.play();
612 assertEquals(Status.RUNNING, pt.getStatus());
613 assertEquals(Status.RUNNING, child1X.getStatus());
614 assertEquals(Status.RUNNING, child1Y.getStatus());
615 assertEquals(6000, xProperty.get());
616 assertEquals(6000, yProperty.get());
617
618 amt.pulse();
619 assertEquals(Status.RUNNING, pt.getStatus());
620 assertEquals(Status.RUNNING, child1X.getStatus());
621 assertEquals(Status.RUNNING, child1Y.getStatus());
622 assertEquals(6000 + TICK_STEP, xProperty.get());
623 assertEquals(6000 + TICK_STEP, yProperty.get());
624
625 pt.pause();
626 pt.jumpTo(Duration.seconds(7));
627 pt.jumpTo(Duration.seconds(9));
628 assertEquals(Status.PAUSED, pt.getStatus());
629 assertEquals(Status.PAUSED, child1X.getStatus());
630 assertEquals(Status.PAUSED, child1Y.getStatus());
631 assertEquals(9000, xProperty.get());
632 assertEquals(9000, yProperty.get());
633
634 pt.play();
635 assertEquals(Status.RUNNING, pt.getStatus());
636 assertEquals(Status.RUNNING, child1X.getStatus());
637 assertEquals(Status.RUNNING, child1Y.getStatus());
638 assertEquals(9000, xProperty.get());
639 assertEquals(9000, yProperty.get());
640
641 amt.pulse();
642 assertEquals(Status.RUNNING, pt.getStatus());
643 assertEquals(Status.RUNNING, child1X.getStatus());
644 assertEquals(Status.RUNNING, child1Y.getStatus());
645 assertEquals(9000 + TICK_STEP, xProperty.get());
646 assertEquals(9000 + TICK_STEP, yProperty.get());
647
648 pt.pause();
649 assertEquals(Status.PAUSED, pt.getStatus());
650 assertEquals(Status.PAUSED, child1X.getStatus());
651 assertEquals(Status.PAUSED, child1Y.getStatus());
652 assertEquals(9000 + TICK_STEP, xProperty.get());
653 assertEquals(9000 + TICK_STEP, yProperty.get());
654
655 pt.jumpTo(Duration.seconds(10).subtract(TickCalculation.toDuration(100)));
656 assertEquals(Status.PAUSED, pt.getStatus());
657 assertEquals(Status.PAUSED, child1X.getStatus());
658 assertEquals(Status.PAUSED, child1Y.getStatus());
659 assertEquals(10000 - TICK_STEP, xProperty.get());
660 assertEquals(10000 - TICK_STEP, yProperty.get());
661
662 pt.play();
663 assertEquals(Status.RUNNING, pt.getStatus());
664 assertEquals(Status.RUNNING, child1X.getStatus());
665 assertEquals(Status.RUNNING, child1Y.getStatus());
666 assertEquals(10000 - TICK_STEP, xProperty.get());
667 assertEquals(10000 - TICK_STEP, yProperty.get());
668
669 amt.pulse();
670 assertEquals(Status.RUNNING, pt.getStatus());
671 assertEquals(Status.RUNNING, child1X.getStatus());
672 assertEquals(Status.STOPPED, child1Y.getStatus());
673 assertEquals(10000, xProperty.get());
674 assertEquals(10000, yProperty.get());
675
676 pt.pause();
677 pt.jumpTo(Duration.seconds(60).subtract(TickCalculation.toDuration(100)));
678 assertEquals(Status.PAUSED, pt.getStatus());
679 assertEquals(Status.PAUSED, child1X.getStatus());
680 assertEquals(Status.STOPPED, child1Y.getStatus());
681 assertEquals(60000 - TICK_STEP, xProperty.get());
682 assertEquals(10000, yProperty.get());
683
684 pt.play();
685 assertEquals(Status.RUNNING, pt.getStatus());
686 assertEquals(Status.RUNNING, child1X.getStatus());
687 assertEquals(Status.STOPPED, child1Y.getStatus());
688 assertEquals(60000 - TICK_STEP, xProperty.get());
689 assertEquals(10000, yProperty.get());
690
691 amt.pulse();
692 assertEquals(Status.STOPPED, pt.getStatus());
693 assertEquals(Status.STOPPED, child1X.getStatus());
694 assertEquals(Status.STOPPED, child1Y.getStatus());
695 assertEquals(60000, xProperty.get());
696 assertEquals(10000, yProperty.get());
697 }
698
699 @Test
700 public void testPauseForward2() {
701 pt.getChildren().addAll(child1X, child1Y);
702
703 pt.play();
704 pt.jumpTo(Duration.seconds(5));
705 amt.pulse();
706 pt.pause();
707 assertEquals(Status.PAUSED, pt.getStatus());
708 assertEquals(Status.PAUSED, child1X.getStatus());
709 assertEquals(Status.PAUSED, child1Y.getStatus());
710 assertEquals(5000 + TICK_STEP, xProperty.get());
711 assertEquals(5000 + TICK_STEP, yProperty.get());
712
713 pt.jumpTo(Duration.seconds(30));
714 assertEquals(Status.PAUSED, pt.getStatus());
715 assertEquals(Status.PAUSED, child1X.getStatus());
716 assertEquals(Status.STOPPED, child1Y.getStatus());
717 assertEquals(30000, xProperty.get());
718 assertEquals(10000, yProperty.get());
719
720 pt.play();
721 assertEquals(Status.RUNNING, pt.getStatus());
722 assertEquals(Status.RUNNING, child1X.getStatus());
723 assertEquals(Status.STOPPED, child1Y.getStatus());
724 assertEquals(30000, xProperty.get());
725 assertEquals(10000, yProperty.get());
726
727 amt.pulse();
728 assertEquals(Status.RUNNING, pt.getStatus());
729 assertEquals(Status.RUNNING, child1X.getStatus());
730 assertEquals(Status.STOPPED, child1Y.getStatus());
731 assertEquals(30000 + TICK_STEP, xProperty.get());
732 assertEquals(10000, yProperty.get());
733
734 pt.pause();
735 pt.jumpTo(Duration.seconds(60).subtract(TickCalculation.toDuration(100)));
736 assertEquals(Status.PAUSED, pt.getStatus());
737 assertEquals(Status.PAUSED, child1X.getStatus());
738 assertEquals(Status.STOPPED, child1Y.getStatus());
739 assertEquals(60000 - TICK_STEP, xProperty.get());
740 assertEquals(10000, yProperty.get());
741
742 pt.play();
743 assertEquals(Status.RUNNING, pt.getStatus());
744 assertEquals(Status.RUNNING, child1X.getStatus());
745 assertEquals(Status.STOPPED, child1Y.getStatus());
746 assertEquals(60000 - TICK_STEP, xProperty.get());
747 assertEquals(10000, yProperty.get());
748
749 amt.pulse();
750 assertEquals(Status.STOPPED, pt.getStatus());
751 assertEquals(Status.STOPPED, child1X.getStatus());
752 assertEquals(Status.STOPPED, child1Y.getStatus());
753 assertEquals(60000, xProperty.get());
754 assertEquals(10000, yProperty.get());
755 }
756
757 @Test
758 public void testPauseAutoReverse() {
759 pt.getChildren().addAll(child1X, child1Y);
760 pt.setAutoReverse(true);
761 pt.setCycleCount(-1);
762
763 pt.play();
764 pt.jumpTo(Duration.seconds(5));
765 amt.pulse();
766 pt.pause();
767 assertEquals(Status.PAUSED, pt.getStatus());
768 assertEquals(Status.PAUSED, child1X.getStatus());
769 assertEquals(Status.PAUSED, child1Y.getStatus());
770 assertEquals(5000 + TICK_STEP, xProperty.get());
771 assertEquals(5000 + TICK_STEP, yProperty.get());
772
773 pt.jumpTo(Duration.seconds(60).subtract(TickCalculation.toDuration(100)));
774 assertEquals(Status.PAUSED, pt.getStatus());
775 assertEquals(Status.PAUSED, child1X.getStatus());
776 assertEquals(Status.STOPPED, child1Y.getStatus());
777 assertEquals(60000 - TICK_STEP, xProperty.get());
778 assertEquals(10000, yProperty.get());
779
780 pt.play();
781 assertEquals(Status.RUNNING, pt.getStatus());
782 assertEquals(Status.RUNNING, child1X.getStatus());
783 assertEquals(Status.STOPPED, child1Y.getStatus());
784 assertEquals(60000 - TICK_STEP, xProperty.get());
785 assertEquals(10000, yProperty.get());
786
787 amt.pulse();
788 assertEquals(Status.RUNNING, pt.getStatus());
789 assertEquals(Status.STOPPED, child1X.getStatus());
790 assertEquals(Status.STOPPED, child1Y.getStatus());
791 assertEquals(60000, xProperty.get());
792 assertEquals(10000, yProperty.get());
793
794 amt.pulse();
795 assertEquals(Status.RUNNING, pt.getStatus());
796 assertEquals(Status.RUNNING, child1X.getStatus());
797 assertEquals(Status.STOPPED, child1Y.getStatus());
798 assertEquals(60000 - TICK_STEP, xProperty.get());
799 assertEquals(10000, yProperty.get());
800
801 pt.pause();
802 pt.jumpTo(Duration.seconds(110).subtract(TickCalculation.toDuration(100)));
803 assertEquals(Status.PAUSED, pt.getStatus());
804 assertEquals(Status.PAUSED, child1X.getStatus());
805 assertEquals(Status.STOPPED, child1Y.getStatus());
806 assertEquals(10000 + TICK_STEP, xProperty.get());
807 assertEquals(10000, yProperty.get());
808
809 pt.play();
810 assertEquals(Status.RUNNING, pt.getStatus());
811 assertEquals(Status.RUNNING, child1X.getStatus());
812 assertEquals(Status.STOPPED, child1Y.getStatus());
813 assertEquals(10000 + TICK_STEP, xProperty.get());
814 assertEquals(10000, yProperty.get());
815
816 amt.pulse();
817 assertEquals(Status.RUNNING, pt.getStatus());
818 assertEquals(Status.RUNNING, child1X.getStatus());
819 assertEquals(Status.STOPPED, child1Y.getStatus());
820 assertEquals(10000, xProperty.get());
821 assertEquals(10000, yProperty.get());
822
823 amt.pulse();
824 assertEquals(Status.RUNNING, pt.getStatus());
825 assertEquals(Status.RUNNING, child1X.getStatus());
826 assertEquals(Status.RUNNING, child1Y.getStatus());
827 assertEquals(10000 - TICK_STEP, xProperty.get());
828 assertEquals(10000 - TICK_STEP, yProperty.get());
829
830 pt.pause();
831 pt.jumpTo(Duration.seconds(120).subtract(TickCalculation.toDuration(100)));
832 assertEquals(Status.PAUSED, pt.getStatus());
833 assertEquals(Status.PAUSED, child1X.getStatus());
834 assertEquals(Status.PAUSED, child1Y.getStatus());
835 assertEquals(0 + TICK_STEP, xProperty.get());
836 assertEquals(0 + TICK_STEP, yProperty.get());
837
838 pt.play();
839 assertEquals(Status.RUNNING, pt.getStatus());
840 assertEquals(Status.RUNNING, child1X.getStatus());
841 assertEquals(Status.RUNNING, child1Y.getStatus());
842 assertEquals(0 + TICK_STEP, xProperty.get());
843 assertEquals(0 + TICK_STEP, yProperty.get());
844
845 amt.pulse();
846 assertEquals(Status.RUNNING, pt.getStatus());
847 assertEquals(Status.STOPPED, child1X.getStatus());
848 assertEquals(Status.STOPPED, child1Y.getStatus());
849 assertEquals(0, xProperty.get());
850 assertEquals(0, yProperty.get());
851
852 amt.pulse();
853 assertEquals(Status.RUNNING, pt.getStatus());
854 assertEquals(Status.RUNNING, child1X.getStatus());
855 assertEquals(Status.RUNNING, child1Y.getStatus());
856 assertEquals(0 + TICK_STEP, xProperty.get());
857 assertEquals(0 + TICK_STEP, yProperty.get());
858 }
859
860
861 @Test public void testNestedParallelTransition() {
862 ParallelTransition pt2 = new ParallelTransition();
863
864 pt.getChildren().addAll(pt2, child1X);
865 pt2.getChildren().add(child1Y);
866
867 pt.play();
868
869 amt.pulse();
870
871 assertEquals(Status.RUNNING, pt.getStatus());
872 assertEquals(Status.RUNNING, pt2.getStatus());
873 assertEquals(Status.RUNNING, child1X.getStatus());
874 assertEquals(Status.RUNNING, child1Y.getStatus());
875 assertEquals(TICK_STEP, xProperty.get());
876 assertEquals(TICK_STEP, yProperty.get());
877
878 amt.pulse();
879
880 assertEquals(Status.RUNNING, pt.getStatus());
881 assertEquals(Status.RUNNING, pt2.getStatus());
882 assertEquals(Status.RUNNING, child1X.getStatus());
883 assertEquals(Status.RUNNING, child1Y.getStatus());
884 assertEquals(Math.round(TICK_MILLIS * 2), xProperty.get());
885 assertEquals(Math.round(TICK_MILLIS * 2), yProperty.get());
886
887
888 pt.jumpTo(Duration.seconds(60).subtract(TickCalculation.toDuration(100)));
889
890 amt.pulse();
891
892 assertEquals(Status.STOPPED, pt.getStatus());
893 assertEquals(Status.STOPPED, pt2.getStatus());
894 assertEquals(Status.STOPPED, child1X.getStatus());
895 assertEquals(Status.STOPPED, child1Y.getStatus());
896
897 pt.play();
898
899
900 amt.pulse();
901
902 assertEquals(Status.RUNNING, pt.getStatus());
903 assertEquals(Status.RUNNING, pt2.getStatus());
904 assertEquals(Status.RUNNING, child1X.getStatus());
905 assertEquals(Status.RUNNING, child1Y.getStatus());
906 assertEquals(TICK_STEP, xProperty.get());
907 assertEquals(TICK_STEP, yProperty.get());
908
909 amt.pulse();
910
911 assertEquals(Status.RUNNING, pt.getStatus());
912 assertEquals(Status.RUNNING, pt2.getStatus());
913 assertEquals(Status.RUNNING, child1X.getStatus());
914 assertEquals(Status.RUNNING, child1Y.getStatus());
915 assertEquals(Math.round(TICK_MILLIS * 2), xProperty.get());
916 assertEquals(Math.round(TICK_MILLIS * 2), yProperty.get());
917
918
919 pt.jumpTo(Duration.seconds(60).subtract(TickCalculation.toDuration(100)));
920
921 amt.pulse();
922
923 assertEquals(Status.STOPPED, pt.getStatus());
924 assertEquals(Status.STOPPED, pt2.getStatus());
925 assertEquals(Status.STOPPED, child1X.getStatus());
926 assertEquals(Status.STOPPED, child1Y.getStatus());
927 }
928
929 @Test
930 public void testPlayFromStartSynchronization() {
931 pt.getChildren().addAll(child1Y, childByX);
932
933 pt.play();
934
935 assertEquals(0, yProperty.get());
936 assertEquals(0, xProperty.get());
937
938 pt.jumpTo(Duration.seconds(10));
939 amt.pulse();
940
941 pt.play();
942 assertEquals(0, yProperty.get());
943 assertEquals(1000, xProperty.get());
944
945 pt.jumpTo(Duration.seconds(10));
946 amt.pulse();
947
948 assertEquals(10000, yProperty.get());
949 assertEquals(2000, xProperty.get());
950
951 }
952
953 @Test
954 public void testCycleSynchronization() {
955 pt.setCycleCount(2);
956 pt.getChildren().addAll(childByX);
957
958 pt.play();
959
960 assertEquals(0, xProperty.get());
961
962 pt.jumpTo(Duration.seconds(1));
963 amt.pulse();
964
965 assertEquals(TICK_STEP, xProperty.get());
966
967 pt.jumpTo(Duration.seconds(2));
968 amt.pulse();
969
970 assertEquals(1000, xProperty.get());
971
972 }
973
974 }