modules/graphics/src/test/java/test/javafx/animation/AnimationTest.java

Print this page
rev 9250 : 8134762: Refactor Javafx graphics module tests for clear separation of tests
Reviewed-by:

@@ -21,29 +21,29 @@
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 
-package javafx.animation;
+package test.javafx.animation;
 
+import com.sun.javafx.tk.Toolkit;
+import test.com.sun.scenario.animation.shared.ClipEnvelopeMock;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintStream;
-
-import com.sun.javafx.tk.Toolkit;
+import javafx.animation.Animation;
 import javafx.animation.Animation.Status;
 import javafx.event.ActionEvent;
 import javafx.event.EventHandler;
 import javafx.util.Duration;
-import com.sun.scenario.animation.AbstractMasterTimerMock;
-import com.sun.scenario.animation.shared.ClipEnvelopeMock;
 import org.junit.After;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 import org.junit.Before;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
-
 public class AnimationTest {
 
     private static final Duration ONE_SEC = Duration.millis(1000);
     private static final Duration TWO_SECS = Duration.millis(2000);
     private static final Duration THREE_SECS = Duration.millis(3000);

@@ -54,19 +54,19 @@
     private static final boolean DEFAULT_AUTO_REVERSE = false;
 
     private static final double EPSILON = 1e-12;
 
     private AbstractMasterTimerMock timer;
-    private Animation animation;
+    private AnimationImpl animation;
     private ClipEnvelopeMock clipEnvelope;
 
     @Before
     public void setUp() {
         timer = new AbstractMasterTimerMock();
         clipEnvelope = new ClipEnvelopeMock();
         animation = new AnimationImpl(timer, clipEnvelope, 1);
-        animation.setCycleDuration(ONE_SEC);
+        animation.shim_setCycleDuration(ONE_SEC);
         clipEnvelope.setAnimation(animation);
     }
 
     @After
     public void tearDown() {

@@ -127,22 +127,22 @@
         animation.setCycleCount(Animation.INDEFINITE);
         assertEquals(Duration.INDEFINITE, animation.getTotalDuration());
         animation.setCycleCount(1);
 
         // Duration.ZERO
-        animation.setCycleDuration(Duration.ZERO);
+        animation.shim_setCycleDuration(Duration.ZERO);
         assertEquals(Duration.ZERO, animation.getTotalDuration());
         animation.setCycleCount(0);
         assertEquals(Duration.ZERO, animation.getTotalDuration());
         animation.setCycleCount(7);
         assertEquals(Duration.ZERO, animation.getTotalDuration());
         animation.setCycleCount(Animation.INDEFINITE);
         assertEquals(Duration.ZERO, animation.getTotalDuration());
         animation.setCycleCount(1);
 
         // Duration.INDEFINITE
-        animation.setCycleDuration(Duration.INDEFINITE);
+        animation.shim_setCycleDuration(Duration.INDEFINITE);
         assertEquals(Duration.INDEFINITE, animation.getTotalDuration());
         animation.setCycleCount(0);
         assertEquals(Duration.INDEFINITE, animation.getTotalDuration());
         animation.setCycleCount(7);
         assertEquals(Duration.INDEFINITE, animation.getTotalDuration());

@@ -152,19 +152,20 @@
     }
 
     @Test
     public void testDecreaseTotalDuration() {
         animation.jumpTo(ONE_SEC);
-        animation.setCycleDuration(ONE_SEC.divide(2));
+        animation.shim_setCycleDuration(ONE_SEC.divide(2));
         assertEquals(ONE_SEC.divide(2), animation.getCurrentTime());
-        animation.setCycleDuration(Duration.ZERO);
+        animation.shim_setCycleDuration(Duration.ZERO);
         assertEquals(Duration.ZERO, animation.getCurrentTime());
     }
 
     @Test
     public void testJumpTo() {
-        animation.setCycleDuration(TWO_SECS);
+        animation.shim_setCycleDuration(TWO_SECS);
+        assertEquals(TWO_SECS,animation.getCycleDuration());
 
         // cycleCount = 1
         animation.jumpTo(ONE_SEC);
         assertEquals(ONE_SEC, animation.getCurrentTime());
         assertEquals(6000, clipEnvelope.getLastJumpTo());

@@ -206,11 +207,11 @@
         assertEquals(0, clipEnvelope.getLastJumpTo());
     }
 
     @Test
     public void testJumpTo_ZeroLengthAnimation() {
-        animation.setCycleDuration(Duration.ZERO);
+        animation.shim_setCycleDuration(Duration.ZERO);
 
         // cycleCount = 1
         animation.jumpTo(Duration.ZERO);
         assertEquals(Duration.ZERO, animation.getCurrentTime());
         assertEquals(0, clipEnvelope.getLastJumpTo());

@@ -229,11 +230,11 @@
     }
 
     @Test
     public void testDurationRoundingError() {
         final Duration duration = Duration.millis(0.01);
-        animation.setCycleDuration(duration);
+        animation.shim_setCycleDuration(duration);
         assertTrue(animation.getCycleDuration().greaterThan(Duration.ZERO));
 
         // should not be startable
         assertFalse(animation.impl_startable(true));
 

@@ -255,11 +256,11 @@
 
     @Test
     public void testJumpToCuePoint_Default() {
         animation.getCuePoints().put("ONE_SEC", ONE_SEC);
         animation.getCuePoints().put("THREE_SECS", THREE_SECS);
-        animation.setCycleDuration(TWO_SECS);
+        animation.shim_setCycleDuration(TWO_SECS);
 
         // normal jumps
         animation.jumpTo("end");
         assertEquals(TWO_SECS, animation.getCurrentTime());
         animation.jumpTo("start");

@@ -277,11 +278,11 @@
     }
 
     @Test
     public void testJumpToCuePoint_ZeroLengthAnimation() {
         animation.getCuePoints().put("ONE_SEC", ONE_SEC);
-        animation.setCycleDuration(Duration.ZERO);
+        animation.shim_setCycleDuration(Duration.ZERO);
 
         animation.jumpTo("start");
         assertEquals(Duration.ZERO, animation.getCurrentTime());
         animation.jumpTo("end");
         assertEquals(Duration.ZERO, animation.getCurrentTime());

@@ -302,111 +303,111 @@
         // stopped timeline
         listener.wasCalled = false;
         animation.play();
         assertEquals(Status.RUNNING, animation.getStatus());
         assertFalse(listener.wasCalled);
-        assertTrue(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertTrue(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
 
         // calling play on playing timeline
         animation.play();
         assertEquals(Status.RUNNING, animation.getStatus());
         assertFalse(listener.wasCalled);
-        assertTrue(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertTrue(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
         animation.stop();
 
         // stopped timeline, rate = 0
         listener.wasCalled = false;
         animation.setRate(0.0);
         animation.play();
         assertEquals(Status.RUNNING, animation.getStatus());
         assertFalse(listener.wasCalled);
-        assertFalse(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertFalse(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
         animation.stop();
         animation.setRate(1.0);
 
         // stopped timeline, cycleDuration = 0
         listener.wasCalled = false;
-        animation.setCycleDuration(Duration.ZERO);
+        animation.shim_setCycleDuration(Duration.ZERO);
         animation.play();
         assertEquals(Status.STOPPED, animation.getStatus());
         assertTrue(listener.wasCalled);
-        assertFalse(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertFalse(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
         animation.stop();
-        animation.setCycleDuration(ONE_SEC);
+        animation.shim_setCycleDuration(ONE_SEC);
 
         // paused timeline
         animation.play();
         animation.pause();
         animation.play();
         assertEquals(Status.RUNNING, animation.getStatus());
-        assertTrue(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertTrue(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
         animation.stop();
 
         // paused timeline, rate = 0
         animation.play();
         animation.pause();
         animation.setRate(0.0);
         animation.play();
         assertEquals(Status.RUNNING, animation.getStatus());
-        assertFalse(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertFalse(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
     }
 
     @Test
     public void testStop() {
         // stopped timeline
         animation.jumpTo(ONE_SEC);
         animation.stop();
         assertEquals(Status.STOPPED, animation.getStatus());
         assertEquals(0.0, animation.getCurrentRate(), EPSILON);
         assertEquals(ONE_SEC, animation.getCurrentTime());
-        assertFalse(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertFalse(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
 
         // playing timeline
         animation.jumpTo(ONE_SEC);
         animation.play();
         animation.stop();
         assertEquals(Status.STOPPED, animation.getStatus());
         assertEquals(0.0, animation.getCurrentRate(), EPSILON);
         assertEquals(Duration.ZERO, animation.getCurrentTime());
-        assertFalse(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertFalse(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
 
         // paused timeline
         animation.jumpTo(ONE_SEC);
         animation.play();
         animation.pause();
         animation.stop();
         assertEquals(Status.STOPPED, animation.getStatus());
         assertEquals(0.0, animation.getCurrentRate(), EPSILON);
         assertEquals(Duration.ZERO, animation.getCurrentTime());
-        assertFalse(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertFalse(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
     }
 
     @Test
     public void testPause() {
         // stopped timeline
         animation.jumpTo(ONE_SEC);
         animation.pause();
         assertEquals(Status.STOPPED, animation.getStatus());
         assertEquals(0.0, animation.getCurrentRate(), EPSILON);
-        assertFalse(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertFalse(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
 
         // playing timeline
         animation.jumpTo(ONE_SEC);
         animation.play();
         animation.pause();
         assertEquals(Status.PAUSED, animation.getStatus());
         assertEquals(0.0, animation.getCurrentRate(), EPSILON);
-        assertFalse(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertFalse(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
 
         // paused timeline
         animation.jumpTo(ONE_SEC);
         animation.play();
         animation.pause();
         animation.pause();
         assertEquals(Status.PAUSED, animation.getStatus());
         assertEquals(0.0, animation.getCurrentRate(), EPSILON);
-        assertFalse(timer.containsPulseReceiver(animation.pulseReceiver));
+        assertFalse(timer.containsPulseReceiver(animation.shim_pulseReceiver()));
     }
 
     @Test
     public void testStart() {
         // cycleDuration = 1000ms

@@ -416,14 +417,14 @@
         assertEquals(1.0, animation.getCurrentRate(), EPSILON);
         assertEquals(6000, clipEnvelope.getTimelineTicks());
         assertEquals(1.0, clipEnvelope.getRate(), EPSILON);
         assertEquals(false, clipEnvelope.getAutoReverse());
         assertEquals(1, clipEnvelope.getCycleCount());
-        animation.impl_finished();
+        animation.shim_impl_finished();
 
         // change all values and try again
-        animation.setCycleDuration(TWO_SECS);
+        animation.shim_setCycleDuration(TWO_SECS);
         animation.setRate(-2.0);
         animation.setAutoReverse(true);
         animation.setCycleCount(Animation.INDEFINITE);
         assertTrue(animation.impl_startable(true));
         animation.impl_start(true);

@@ -431,28 +432,28 @@
         assertEquals(-2.0, animation.getCurrentRate(), EPSILON);
         assertEquals(12000, clipEnvelope.getTimelineTicks());
         assertEquals(-2.0, clipEnvelope.getRate(), EPSILON);
         assertEquals(true, clipEnvelope.getAutoReverse());
         assertEquals(Animation.INDEFINITE, clipEnvelope.getCycleCount());
-        animation.impl_finished();
+        animation.shim_impl_finished();
 
         // cycleDuration = 0
-        animation.setCycleDuration(Duration.ZERO);
+        animation.shim_setCycleDuration(Duration.ZERO);
         assertFalse(animation.impl_startable(true));
     }
 
     @Test
     public void testChangeCycleDurationAfterFinish_RT32657() {
-        animation.setCycleDuration(TWO_SECS);
+        animation.shim_setCycleDuration(TWO_SECS);
         animation.play();
         assertEquals(Status.RUNNING, animation.getStatus());
         assertEquals(Duration.ZERO, animation.getCurrentTime());
         animation.impl_setCurrentTicks(12000);
         assertEquals(TWO_SECS, animation.getCurrentTime());
-        animation.impl_finished();
+        animation.shim_impl_finished();
 
-        animation.setCycleDuration(ONE_SEC);
+        animation.shim_setCycleDuration(ONE_SEC);
         animation.play();
         assertEquals(Status.RUNNING, animation.getStatus());
         assertEquals(Duration.ZERO, animation.getCurrentTime());
     }
 

@@ -460,26 +461,26 @@
     public void testFinished() {
         final OnFinishedListener listener = new OnFinishedListener();
         animation.setOnFinished(listener);
 
         // stopped timeline
-        animation.impl_finished();
+        animation.shim_impl_finished();
         assertEquals(Status.STOPPED, animation.getStatus());
         assertEquals(0.0, animation.getCurrentRate(), EPSILON);
         assertTrue(listener.wasCalled);
 
         // playing timeline
         animation.play();
-        animation.impl_finished();
+        animation.shim_impl_finished();
         assertEquals(Status.STOPPED, animation.getStatus());
         assertEquals(0.0, animation.getCurrentRate(), EPSILON);
         assertTrue(listener.wasCalled);
 
         // paused timeline
         animation.play();
         animation.pause();
-        animation.impl_finished();
+        animation.shim_impl_finished();
         assertEquals(Status.STOPPED, animation.getStatus());
         assertEquals(0.0, animation.getCurrentRate(), EPSILON);
         assertTrue(listener.wasCalled);
     }
 

@@ -498,11 +499,11 @@
         try {
             System.setErr(nirvana);
         } catch (SecurityException ex) {
             // ignore
         }
-        animation.impl_finished();
+        animation.shim_impl_finished();
         try {
             System.setErr(defaultErrorStream);
         } catch (SecurityException ex) {
             // ignore
         }

@@ -515,11 +516,11 @@
         try {
             System.setErr(nirvana);
         } catch (SecurityException ex) {
             // ignore
         }
-        animation.impl_finished();
+        animation.shim_impl_finished();
         try {
             System.setErr(defaultErrorStream);
         } catch (SecurityException ex) {
             // ignore
         }

@@ -533,11 +534,11 @@
         try {
             System.setErr(nirvana);
         } catch (SecurityException ex) {
             // ignore
         }
-        animation.impl_finished();
+        animation.shim_impl_finished();
         try {
             System.setErr(defaultErrorStream);
         } catch (SecurityException ex) {
             // ignore
         }