1 /*
2 * Copyright (c) 2011, 2013, 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 javafx.animation;
27
28 import static org.junit.Assert.assertEquals;
29 import static org.junit.Assert.assertFalse;
30 import static org.junit.Assert.assertNull;
31 import static org.junit.Assert.assertTrue;
32 import javafx.scene.Node;
33 import javafx.scene.shape.Rectangle;
34 import javafx.util.Duration;
35
36 import org.junit.Before;
37 import org.junit.Test;
38
39 public class ScaleTransitionTest {
40
41 private static Duration DEFAULT_DURATION = Duration.millis(400);
42 private static Interpolator DEFAULT_INTERPOLATOR = Interpolator.EASE_BOTH;
43
44 private static double EPSILON = 1e-12;
45 private static Duration ONE_SEC = Duration.millis(1000);
46 private static Duration TWO_SECS = Duration.millis(2000);
47
48 private Node node;
49
50 @Before
51 public void setUp() {
52 node = new Rectangle();
53 }
54
55 @Test
56 public void testDefaultValues() {
57 // empty ctor
58 final ScaleTransition t0 = new ScaleTransition();
59 assertEquals(DEFAULT_DURATION, t0.getDuration());
60 assertEquals(DEFAULT_DURATION, t0.getCycleDuration());
61 assertTrue(Double.isNaN(t0.getFromX()));
62 assertTrue(Double.isNaN(t0.getFromY()));
63 assertTrue(Double.isNaN(t0.getFromZ()));
64 assertTrue(Double.isNaN(t0.getToX()));
65 assertTrue(Double.isNaN(t0.getToY()));
66 assertTrue(Double.isNaN(t0.getToZ()));
67 assertEquals(0.0, t0.getByX(), EPSILON);
68 assertEquals(0.0, t0.getByY(), EPSILON);
69 assertEquals(0.0, t0.getByZ(), EPSILON);
70 assertNull(t0.getNode());
71 assertEquals(DEFAULT_INTERPOLATOR, t0.getInterpolator());
72 assertNull(t0.getOnFinished());
73
74 // duration only
75 final ScaleTransition t1 = new ScaleTransition(ONE_SEC);
76 assertEquals(ONE_SEC, t1.getDuration());
77 assertTrue(Double.isNaN(t1.getFromX()));
78 assertTrue(Double.isNaN(t1.getFromY()));
79 assertTrue(Double.isNaN(t1.getFromZ()));
80 assertTrue(Double.isNaN(t1.getToX()));
81 assertTrue(Double.isNaN(t1.getToY()));
82 assertTrue(Double.isNaN(t1.getToZ()));
83 assertEquals(0.0, t1.getByX(), EPSILON);
84 assertEquals(0.0, t1.getByY(), EPSILON);
85 assertEquals(0.0, t1.getByZ(), EPSILON);
86 assertNull(t1.getNode());
87 assertEquals(DEFAULT_INTERPOLATOR, t1.getInterpolator());
88 assertNull(t1.getOnFinished());
89
90 // duration and node
91 final ScaleTransition t2 = new ScaleTransition(TWO_SECS, node);
92 assertEquals(TWO_SECS, t2.getDuration());
93 assertTrue(Double.isNaN(t2.getFromX()));
94 assertTrue(Double.isNaN(t2.getFromY()));
95 assertTrue(Double.isNaN(t2.getFromZ()));
96 assertTrue(Double.isNaN(t2.getToX()));
97 assertTrue(Double.isNaN(t2.getToY()));
98 assertTrue(Double.isNaN(t2.getToZ()));
99 assertEquals(0.0, t2.getByX(), EPSILON);
100 assertEquals(0.0, t2.getByY(), EPSILON);
101 assertEquals(0.0, t2.getByZ(), EPSILON);
102 assertEquals(node, t2.getNode());
103 assertEquals(DEFAULT_INTERPOLATOR, t2.getInterpolator());
104 assertNull(t2.getOnFinished());
105 }
106
107 @Test
108 public void testDefaultValuesFromProperties() {
109 // empty ctor
110 final ScaleTransition t0 = new ScaleTransition();
111 assertEquals(DEFAULT_DURATION, t0.durationProperty().get());
112 assertTrue(Double.isNaN(t0.fromXProperty().get()));
113 assertTrue(Double.isNaN(t0.fromYProperty().get()));
114 assertTrue(Double.isNaN(t0.fromZProperty().get()));
115 assertTrue(Double.isNaN(t0.toXProperty().get()));
116 assertTrue(Double.isNaN(t0.toYProperty().get()));
117 assertTrue(Double.isNaN(t0.toZProperty().get()));
118 assertEquals(0.0, t0.byXProperty().get(), EPSILON);
119 assertEquals(0.0, t0.byYProperty().get(), EPSILON);
120 assertEquals(0.0, t0.byZProperty().get(), EPSILON);
121 assertNull(t0.nodeProperty().get());
122 assertEquals(DEFAULT_INTERPOLATOR, t0.interpolatorProperty().get());
123 assertNull(t0.onFinishedProperty().get());
124
125 // duration only
126 final ScaleTransition t1 = new ScaleTransition(ONE_SEC);
127 assertEquals(ONE_SEC, t1.durationProperty().get());
128 assertTrue(Double.isNaN(t1.fromXProperty().get()));
129 assertTrue(Double.isNaN(t1.fromYProperty().get()));
130 assertTrue(Double.isNaN(t1.fromZProperty().get()));
131 assertTrue(Double.isNaN(t1.toXProperty().get()));
132 assertTrue(Double.isNaN(t1.toYProperty().get()));
133 assertTrue(Double.isNaN(t1.toZProperty().get()));
134 assertEquals(0.0, t1.byXProperty().get(), EPSILON);
135 assertEquals(0.0, t1.byYProperty().get(), EPSILON);
136 assertEquals(0.0, t1.byZProperty().get(), EPSILON);
137 assertNull(t1.nodeProperty().get());
138 assertEquals(DEFAULT_INTERPOLATOR, t1.interpolatorProperty().get());
139 assertNull(t1.onFinishedProperty().get());
140
141 // duration and node
142 final ScaleTransition t2 = new ScaleTransition(TWO_SECS, node);
143 assertEquals(TWO_SECS, t2.durationProperty().get());
144 assertTrue(Double.isNaN(t2.fromXProperty().get()));
145 assertTrue(Double.isNaN(t2.fromYProperty().get()));
146 assertTrue(Double.isNaN(t2.fromZProperty().get()));
147 assertTrue(Double.isNaN(t2.toXProperty().get()));
148 assertTrue(Double.isNaN(t2.toYProperty().get()));
149 assertTrue(Double.isNaN(t2.toZProperty().get()));
150 assertEquals(0.0, t2.byXProperty().get(), EPSILON);
151 assertEquals(0.0, t2.byYProperty().get(), EPSILON);
152 assertEquals(0.0, t2.byZProperty().get(), EPSILON);
153 assertEquals(node, t2.nodeProperty().get());
154 assertEquals(DEFAULT_INTERPOLATOR, t2.interpolatorProperty().get());
155 assertNull(t2.onFinishedProperty().get());
156 }
157
158 @Test
159 public void testInterpolate() {
160 final ScaleTransition t0 = new ScaleTransition(ONE_SEC, node);
161 t0.setFromX(0.5);
162 t0.setToX(1.0);
163 t0.setFromY(1.5);
164 t0.setToY(2.0);
165 t0.setFromZ(1.5);
166 t0.setToZ(0.5);
167
168 assertTrue(t0.impl_startable(true));
169 t0.impl_start(true);
170 t0.interpolate(0.0);
171 assertEquals(0.5, node.getScaleX(), EPSILON);
172 assertEquals(1.5, node.getScaleY(), EPSILON);
173 assertEquals(1.5, node.getScaleZ(), EPSILON);
174 t0.interpolate(0.4);
175 assertEquals(0.7, node.getScaleX(), EPSILON);
176 assertEquals(1.7, node.getScaleY(), EPSILON);
177 assertEquals(1.1, node.getScaleZ(), EPSILON);
178 t0.interpolate(1.0);
179 assertEquals(1.0, node.getScaleX(), EPSILON);
180 assertEquals(2.0, node.getScaleY(), EPSILON);
181 assertEquals(0.5, node.getScaleZ(), EPSILON);
182 t0.impl_finished();
183 }
184
185 @Test
186 public void testXValueCombinations() {
187 final ScaleTransition t0 = new ScaleTransition(ONE_SEC, node);
188 final double originalValue = 0.6;
189 final double fromValue = 0.4;
190 final double toValue = 0.9;
191 final double byValue = -0.2;
192
193 // no value set
194 node.setScaleX(originalValue);
195 t0.setFromX(Double.NaN);
196 t0.setToX(Double.NaN);
197 t0.setByX(0.0);
198 assertTrue(t0.impl_startable(true));
199 t0.impl_start(true);
200 t0.interpolate(0.0);
201 assertEquals(originalValue, node.getScaleX(), EPSILON);
202 t0.interpolate(1.0);
203 assertEquals(originalValue, node.getScaleX(), EPSILON);
204 t0.impl_finished();
205
206 // only from-value set
207 node.setScaleX(originalValue);
208 t0.setFromX(fromValue);
209 t0.setToX(Double.NaN);
210 t0.setByX(0.0);
211 assertTrue(t0.impl_startable(true));
212 t0.impl_start(true);
213 t0.interpolate(0.0);
214 assertEquals(fromValue, node.getScaleX(), EPSILON);
215 t0.interpolate(1.0);
216 assertEquals(fromValue, node.getScaleX(), EPSILON);
217 t0.impl_finished();
218
219 // only to-value set
220 node.setScaleX(originalValue);
221 t0.setFromX(Double.NaN);
222 t0.setToX(toValue);
223 t0.setByX(0.0);
224 assertTrue(t0.impl_startable(true));
225 t0.impl_start(true);
226 t0.interpolate(0.0);
227 assertEquals(originalValue, node.getScaleX(), EPSILON);
228 t0.interpolate(1.0);
229 assertEquals(toValue, node.getScaleX(), EPSILON);
230 t0.impl_finished();
231
232 // only by-value set
233 node.setScaleX(originalValue);
234 t0.setFromX(Double.NaN);
235 t0.setToX(Double.NaN);
236 t0.setByX(byValue);
237 assertTrue(t0.impl_startable(true));
238 t0.impl_start(true);
239 t0.interpolate(0.0);
240 assertEquals(originalValue, node.getScaleX(), EPSILON);
241 t0.interpolate(1.0);
242 assertEquals(originalValue + byValue, node.getScaleX(), EPSILON);
243 t0.impl_finished();
244
245 // from- and to-values set
246 node.setScaleX(originalValue);
247 t0.setFromX(fromValue);
248 t0.setToX(toValue);
249 t0.setByX(0.0);
250 assertTrue(t0.impl_startable(true));
251 t0.impl_start(true);
252 t0.interpolate(0.0);
253 assertEquals(fromValue, node.getScaleX(), EPSILON);
254 t0.interpolate(1.0);
255 assertEquals(toValue, node.getScaleX(), EPSILON);
256 t0.impl_finished();
257
258 // from- and by-values set
259 node.setScaleX(originalValue);
260 t0.setFromX(fromValue);
261 t0.setToX(Double.NaN);
262 t0.setByX(byValue);
263 assertTrue(t0.impl_startable(true));
264 t0.impl_start(true);
265 t0.interpolate(0.0);
266 assertEquals(fromValue, node.getScaleX(), EPSILON);
267 t0.interpolate(1.0);
268 assertEquals(fromValue + byValue, node.getScaleX(), EPSILON);
269 t0.impl_finished();
270
271 // to- and by-values set
272 node.setScaleX(originalValue);
273 t0.setFromX(Double.NaN);
274 t0.setToX(toValue);
275 t0.setByX(byValue);
276 assertTrue(t0.impl_startable(true));
277 t0.impl_start(true);
278 t0.interpolate(0.0);
279 assertEquals(originalValue, node.getScaleX(), EPSILON);
280 t0.interpolate(1.0);
281 assertEquals(toValue, node.getScaleX(), EPSILON);
282 t0.impl_finished();
283
284 // all values set
285 node.setScaleX(originalValue);
286 t0.setFromX(fromValue);
287 t0.setToX(toValue);
288 t0.setByX(byValue);
289 assertTrue(t0.impl_startable(true));
290 t0.impl_start(true);
291 t0.interpolate(0.0);
292 assertEquals(fromValue, node.getScaleX(), EPSILON);
293 t0.interpolate(1.0);
294 assertEquals(toValue, node.getScaleX(), EPSILON);
295 t0.impl_finished();
296 }
297
298 @Test
299 public void testYValueCombinations() {
300 final ScaleTransition t0 = new ScaleTransition(ONE_SEC, node);
301 final double originalValue = 0.6;
302 final double fromValue = 0.4;
303 final double toValue = 0.9;
304 final double byValue = -0.2;
305
306 // no value set
307 node.setScaleY(originalValue);
308 t0.setFromY(Double.NaN);
309 t0.setToY(Double.NaN);
310 t0.setByY(0.0);
311 assertTrue(t0.impl_startable(true));
312 t0.impl_start(true);
313 t0.interpolate(0.0);
314 assertEquals(originalValue, node.getScaleY(), EPSILON);
315 t0.interpolate(1.0);
316 assertEquals(originalValue, node.getScaleY(), EPSILON);
317 t0.impl_finished();
318
319 // only from-value set
320 node.setScaleY(originalValue);
321 t0.setFromY(fromValue);
322 t0.setToY(Double.NaN);
323 t0.setByY(0.0);
324 assertTrue(t0.impl_startable(true));
325 t0.impl_start(true);
326 t0.interpolate(0.0);
327 assertEquals(fromValue, node.getScaleY(), EPSILON);
328 t0.interpolate(1.0);
329 assertEquals(fromValue, node.getScaleY(), EPSILON);
330 t0.impl_finished();
331
332 // only to-value set
333 node.setScaleY(originalValue);
334 t0.setFromY(Double.NaN);
335 t0.setToY(toValue);
336 t0.setByY(0.0);
337 assertTrue(t0.impl_startable(true));
338 t0.impl_start(true);
339 t0.interpolate(0.0);
340 assertEquals(originalValue, node.getScaleY(), EPSILON);
341 t0.interpolate(1.0);
342 assertEquals(toValue, node.getScaleY(), EPSILON);
343 t0.impl_finished();
344
345 // only by-value set
346 node.setScaleY(originalValue);
347 t0.setFromY(Double.NaN);
348 t0.setToY(Double.NaN);
349 t0.setByY(byValue);
350 assertTrue(t0.impl_startable(true));
351 t0.impl_start(true);
352 t0.interpolate(0.0);
353 assertEquals(originalValue, node.getScaleY(), EPSILON);
354 t0.interpolate(1.0);
355 assertEquals(originalValue + byValue, node.getScaleY(), EPSILON);
356 t0.impl_finished();
357
358 // from- and to-values set
359 node.setScaleY(originalValue);
360 t0.setFromY(fromValue);
361 t0.setToY(toValue);
362 t0.setByY(0.0);
363 assertTrue(t0.impl_startable(true));
364 t0.impl_start(true);
365 t0.interpolate(0.0);
366 assertEquals(fromValue, node.getScaleY(), EPSILON);
367 t0.interpolate(1.0);
368 assertEquals(toValue, node.getScaleY(), EPSILON);
369 t0.impl_finished();
370
371 // from- and by-values set
372 node.setScaleY(originalValue);
373 t0.setFromY(fromValue);
374 t0.setToY(Double.NaN);
375 t0.setByY(byValue);
376 assertTrue(t0.impl_startable(true));
377 t0.impl_start(true);
378 t0.interpolate(0.0);
379 assertEquals(fromValue, node.getScaleY(), EPSILON);
380 t0.interpolate(1.0);
381 assertEquals(fromValue + byValue, node.getScaleY(), EPSILON);
382 t0.impl_finished();
383
384 // to- and by-values set
385 node.setScaleY(originalValue);
386 t0.setFromY(Double.NaN);
387 t0.setToY(toValue);
388 t0.setByY(byValue);
389 assertTrue(t0.impl_startable(true));
390 t0.impl_start(true);
391 t0.interpolate(0.0);
392 assertEquals(originalValue, node.getScaleY(), EPSILON);
393 t0.interpolate(1.0);
394 assertEquals(toValue, node.getScaleY(), EPSILON);
395 t0.impl_finished();
396
397 // all values set
398 node.setScaleY(originalValue);
399 t0.setFromY(fromValue);
400 t0.setToY(toValue);
401 t0.setByY(byValue);
402 assertTrue(t0.impl_startable(true));
403 t0.impl_start(true);
404 t0.interpolate(0.0);
405 assertEquals(fromValue, node.getScaleY(), EPSILON);
406 t0.interpolate(1.0);
407 assertEquals(toValue, node.getScaleY(), EPSILON);
408 t0.impl_finished();
409 }
410
411 @Test
412 public void testZValueCombinations() {
413 final ScaleTransition t0 = new ScaleTransition(ONE_SEC, node);
414 final double originalValue = 0.6;
415 final double fromValue = 0.4;
416 final double toValue = 0.9;
417 final double byValue = -0.2;
418
419 // no value set
420 node.setScaleZ(originalValue);
421 t0.setFromZ(Double.NaN);
422 t0.setToZ(Double.NaN);
423 t0.setByZ(0.0);
424 assertTrue(t0.impl_startable(true));
425 t0.impl_start(true);
426 t0.interpolate(0.0);
427 assertEquals(originalValue, node.getScaleZ(), EPSILON);
428 t0.interpolate(1.0);
429 assertEquals(originalValue, node.getScaleZ(), EPSILON);
430 t0.impl_finished();
431
432 // only from-value set
433 node.setScaleZ(originalValue);
434 t0.setFromZ(fromValue);
435 t0.setToZ(Double.NaN);
436 t0.setByZ(0.0);
437 assertTrue(t0.impl_startable(true));
438 t0.impl_start(true);
439 t0.interpolate(0.0);
440 assertEquals(fromValue, node.getScaleZ(), EPSILON);
441 t0.interpolate(1.0);
442 assertEquals(fromValue, node.getScaleZ(), EPSILON);
443 t0.impl_finished();
444
445 // only to-value set
446 node.setScaleZ(originalValue);
447 t0.setFromZ(Double.NaN);
448 t0.setToZ(toValue);
449 t0.setByZ(0.0);
450 assertTrue(t0.impl_startable(true));
451 t0.impl_start(true);
452 t0.interpolate(0.0);
453 assertEquals(originalValue, node.getScaleZ(), EPSILON);
454 t0.interpolate(1.0);
455 assertEquals(toValue, node.getScaleZ(), EPSILON);
456 t0.impl_finished();
457
458 // only by-value set
459 node.setScaleZ(originalValue);
460 t0.setFromZ(Double.NaN);
461 t0.setToZ(Double.NaN);
462 t0.setByZ(byValue);
463 assertTrue(t0.impl_startable(true));
464 t0.impl_start(true);
465 t0.interpolate(0.0);
466 assertEquals(originalValue, node.getScaleZ(), EPSILON);
467 t0.interpolate(1.0);
468 assertEquals(originalValue + byValue, node.getScaleZ(), EPSILON);
469 t0.impl_finished();
470
471 // from- and to-values set
472 node.setScaleZ(originalValue);
473 t0.setFromZ(fromValue);
474 t0.setToZ(toValue);
475 t0.setByZ(0.0);
476 assertTrue(t0.impl_startable(true));
477 t0.impl_start(true);
478 t0.interpolate(0.0);
479 assertEquals(fromValue, node.getScaleZ(), EPSILON);
480 t0.interpolate(1.0);
481 assertEquals(toValue, node.getScaleZ(), EPSILON);
482 t0.impl_finished();
483
484 // from- and by-values set
485 node.setScaleZ(originalValue);
486 t0.setFromZ(fromValue);
487 t0.setToZ(Double.NaN);
488 t0.setByZ(byValue);
489 assertTrue(t0.impl_startable(true));
490 t0.impl_start(true);
491 t0.interpolate(0.0);
492 assertEquals(fromValue, node.getScaleZ(), EPSILON);
493 t0.interpolate(1.0);
494 assertEquals(fromValue + byValue, node.getScaleZ(), EPSILON);
495 t0.impl_finished();
496
497 // to- and by-values set
498 node.setScaleZ(originalValue);
499 t0.setFromZ(Double.NaN);
500 t0.setToZ(toValue);
501 t0.setByZ(byValue);
502 assertTrue(t0.impl_startable(true));
503 t0.impl_start(true);
504 t0.interpolate(0.0);
505 assertEquals(originalValue, node.getScaleZ(), EPSILON);
506 t0.interpolate(1.0);
507 assertEquals(toValue, node.getScaleZ(), EPSILON);
508 t0.impl_finished();
509
510 // all values set
511 node.setScaleZ(originalValue);
512 t0.setFromZ(fromValue);
513 t0.setToZ(toValue);
514 t0.setByZ(byValue);
515 assertTrue(t0.impl_startable(true));
516 t0.impl_start(true);
517 t0.interpolate(0.0);
518 assertEquals(fromValue, node.getScaleZ(), EPSILON);
519 t0.interpolate(1.0);
520 assertEquals(toValue, node.getScaleZ(), EPSILON);
521 t0.impl_finished();
522 }
523
524 @Test
525 public void testGetTargetNode() {
526 final ScaleTransition t0 = new ScaleTransition(ONE_SEC, node);
527 t0.setInterpolator(Interpolator.LINEAR);
528 t0.setFromX(0.5);
529 t0.setToX(1.0);
530 final Rectangle node2 = new Rectangle();
531 final ParallelTransition pt = new ParallelTransition();
532 pt.getChildren().add(t0);
533 pt.setNode(node2);
534
535 // node set, parent set
536 assertTrue(t0.impl_startable(true));
537 t0.impl_start(true);
538 t0.interpolate(0.5);
539 assertEquals(0.75, node.getScaleX(), EPSILON);
540 assertEquals(1.0, node2.getScaleX(), EPSILON);
541 t0.impl_finished();
542
543 // node null, parent set
544 t0.setNode(null);
545 assertTrue(t0.impl_startable(true));
546 t0.impl_start(true);
547 t0.interpolate(0.4);
548 assertEquals(0.75, node.getScaleX(), EPSILON);
549 assertEquals(0.7, node2.getScaleX(), EPSILON);
550 t0.impl_finished();
551
552 // node null, parent null
553 pt.setNode(null);
554 assertFalse(t0.impl_startable(true));
555 }
556
557 @Test
558 public void testCachedValues() {
559 final ScaleTransition t0 = new ScaleTransition(ONE_SEC, node);
560 t0.setInterpolator(Interpolator.LINEAR);
561 t0.setFromX(0.5);
562 t0.setToX(1.0);
563 t0.setFromY(1.5);
564 t0.setToY(2.0);
565 t0.setFromZ(1.5);
566 t0.setToZ(0.5);
567
568 // start
569 assertTrue(t0.impl_startable(true));
570 t0.impl_start(true);
571 t0.setFromX(0.0);
572 t0.setFromY(-1.0);
573 t0.setFromZ(0.5);
574 t0.interpolate(0.5);
575 assertEquals(0.75, node.getScaleX(), EPSILON);
576 assertEquals(1.75, node.getScaleY(), EPSILON);
577 assertEquals(1.0, node.getScaleZ(), EPSILON);
578 t0.impl_finished();
579 t0.setFromX(0.5);
580 t0.setFromY(1.5);
581 t0.setFromZ(1.5);
582
583 // end
584 assertTrue(t0.impl_startable(true));
585 t0.impl_start(true);
586 t0.setToX(0.0);
587 t0.setFromY(-1.0);
588 t0.setFromZ(1.5);
589 t0.interpolate(0.2);
590 assertEquals(0.6, node.getScaleX(), EPSILON);
591 assertEquals(1.6, node.getScaleY(), EPSILON);
592 assertEquals(1.3, node.getScaleZ(), EPSILON);
593 t0.impl_finished();
594 t0.setToX(1.0);
595 t0.setToY(2.0);
596 t0.setToZ(0.5);
597
598 // node
599 assertTrue(t0.impl_startable(true));
600 t0.impl_start(true);
601 t0.setNode(null);
602 t0.interpolate(0.7);
603 assertEquals(0.85, node.getScaleX(), EPSILON);
604 t0.impl_finished();
605 t0.setNode(node);
606
607 // interpolator
608 assertTrue(t0.impl_startable(true));
609 t0.impl_start(true);
610 t0.setInterpolator(null);
611 t0.interpolate(0.1);
612 assertEquals(0.55, node.getScaleX(), EPSILON);
613 t0.impl_finished();
614 t0.setInterpolator(Interpolator.LINEAR);
615 }
616
617 @Test
618 public void testStartable() {
619 final ScaleTransition t0 = new ScaleTransition(Duration.ONE, node);
620 assertTrue(t0.impl_startable(true));
621
622 // duration is 0
623 t0.setDuration(Duration.ZERO);
624 assertFalse(t0.impl_startable(true));
625 t0.setDuration(Duration.ONE);
626 assertTrue(t0.impl_startable(true));
627
628 // node is null
629 t0.setNode(null);
630 assertFalse(t0.impl_startable(true));
631 t0.setNode(node);
632 assertTrue(t0.impl_startable(true));
633
634 // interpolator is null
635 t0.setInterpolator(null);
636 assertFalse(t0.impl_startable(true));
637 t0.setInterpolator(Interpolator.LINEAR);
638 assertTrue(t0.impl_startable(true));
639 }
640
641 @Test
642 public void testEvaluateStartValue() {
643 final ScaleTransition t0 = new ScaleTransition(Duration.INDEFINITE, node);
644 t0.setToX(2.0);
645 t0.setToY(2.0);
646 t0.setToZ(2.0);
647
648 // first run
649 node.setScaleX( 0.6);
650 node.setScaleY( 1.6);
651 node.setScaleZ(-0.6);
652 assertTrue(t0.impl_startable(true));
653 t0.impl_start(true);
654 node.setScaleX(0.8);
655 node.setScaleY(0.8);
656 node.setScaleZ(0.8);
657 t0.interpolate(0.0);
658 assertEquals( 0.6, node.getScaleX(), EPSILON);
659 assertEquals( 1.6, node.getScaleY(), EPSILON);
660 assertEquals(-0.6, node.getScaleZ(), EPSILON);
661 t0.impl_finished();
662
663 // second run
664 node.setScaleX( 0.2);
665 node.setScaleY(-2.2);
666 node.setScaleZ(11.2);
667 assertTrue(t0.impl_startable(true));
668 t0.impl_start(true);
669 node.setScaleX(0.8);
670 node.setScaleY(0.8);
671 node.setScaleZ(0.8);
672 t0.interpolate(0.0);
673 assertEquals( 0.2, node.getScaleX(), EPSILON);
674 assertEquals(-2.2, node.getScaleY(), EPSILON);
675 assertEquals(11.2, node.getScaleZ(), EPSILON);
676 t0.impl_finished();
677 }
678
679 }