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

*** 1,7 ****
  /*
!  * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
--- 1,7 ----
  /*
!  * Copyright (c) 2011, 2016, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
*** 135,173 ****
      public void testInterpolate() {
          final RotateTransition t0 = new RotateTransition(ONE_SEC, node);
          t0.setFromAngle(0.5);
          t0.setToAngle(1.0);
  
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(0.5, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,0.4);
          assertEquals(0.7, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(1.0, node.getRotate(), EPSILON);
!                 AnimationShim.impl_finished(t0);
      }
  
      @Test
      public void testAxis() {
          final Point3D defaultAxis = new Point3D(0.0, 0.0, 1.0);
          final Point3D axis = new Point3D(1.0, 0.0, 0.0);
          final RotateTransition t0 = new RotateTransition(ONE_SEC, node);
          t0.setAxis(axis);
          node.setRotationAxis(defaultAxis);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          assertEquals(axis, node.getRotationAxis());
!         AnimationShim.impl_finished(t0);
  
          t0.setAxis(null);
          node.setRotationAxis(defaultAxis);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          assertEquals(defaultAxis, node.getRotationAxis());
!         AnimationShim.impl_finished(t0);
      }
  
      @Test
      public void testValueCombinations() {
          final RotateTransition t0 = new RotateTransition(ONE_SEC, node);
--- 135,173 ----
      public void testInterpolate() {
          final RotateTransition t0 = new RotateTransition(ONE_SEC, node);
          t0.setFromAngle(0.5);
          t0.setToAngle(1.0);
  
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(0.5, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,0.4);
          assertEquals(0.7, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(1.0, node.getRotate(), EPSILON);
!                 AnimationShim.finished(t0);
      }
  
      @Test
      public void testAxis() {
          final Point3D defaultAxis = new Point3D(0.0, 0.0, 1.0);
          final Point3D axis = new Point3D(1.0, 0.0, 0.0);
          final RotateTransition t0 = new RotateTransition(ONE_SEC, node);
          t0.setAxis(axis);
          node.setRotationAxis(defaultAxis);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          assertEquals(axis, node.getRotationAxis());
!         AnimationShim.finished(t0);
  
          t0.setAxis(null);
          node.setRotationAxis(defaultAxis);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          assertEquals(defaultAxis, node.getRotationAxis());
!         AnimationShim.finished(t0);
      }
  
      @Test
      public void testValueCombinations() {
          final RotateTransition t0 = new RotateTransition(ONE_SEC, node);
*** 179,286 ****
          // no value set
          node.setRotate(originalAngle);
          t0.setFromAngle(Double.NaN);
          t0.setToAngle(Double.NaN);
          t0.setByAngle(0.0);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(originalAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(originalAngle, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(t0);
  
          // only from-value set
          node.setRotate(originalAngle);
          t0.setFromAngle(fromAngle);
          t0.setToAngle(Double.NaN);
          t0.setByAngle(0.0);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(fromAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(fromAngle, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(t0);
  
          // only to-value set
          node.setRotate(originalAngle);
          t0.setFromAngle(Double.NaN);
          t0.setToAngle(toAngle);
          t0.setByAngle(0.0);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(originalAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(toAngle, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(t0);
  
          // only by-value set
          node.setRotate(originalAngle);
          t0.setFromAngle(Double.NaN);
          t0.setToAngle(Double.NaN);
          t0.setByAngle(byAngle);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(originalAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(originalAngle + byAngle, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(t0);
  
          // from- and to-values set
          node.setRotate(originalAngle);
          t0.setFromAngle(fromAngle);
          t0.setToAngle(toAngle);
          t0.setByAngle(0.0);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(fromAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(toAngle, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(t0);
  
          // from- and by-values set
          node.setRotate(originalAngle);
          t0.setFromAngle(fromAngle);
          t0.setToAngle(Double.NaN);
          t0.setByAngle(byAngle);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(fromAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(fromAngle + byAngle, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(t0);
  
          // to- and by-values set
          node.setRotate(originalAngle);
          t0.setFromAngle(Double.NaN);
          t0.setToAngle(toAngle);
          t0.setByAngle(byAngle);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(originalAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(toAngle, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(t0);
  
          // all values set
          node.setRotate(originalAngle);
          t0.setFromAngle(fromAngle);
          t0.setToAngle(toAngle);
          t0.setByAngle(byAngle);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(fromAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(toAngle, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(t0);
      }
  
      @Test
      public void testGetTargetNode() {
          final RotateTransition rt = new RotateTransition(ONE_SEC, node);
--- 179,286 ----
          // no value set
          node.setRotate(originalAngle);
          t0.setFromAngle(Double.NaN);
          t0.setToAngle(Double.NaN);
          t0.setByAngle(0.0);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(originalAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(originalAngle, node.getRotate(), EPSILON);
!         AnimationShim.finished(t0);
  
          // only from-value set
          node.setRotate(originalAngle);
          t0.setFromAngle(fromAngle);
          t0.setToAngle(Double.NaN);
          t0.setByAngle(0.0);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(fromAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(fromAngle, node.getRotate(), EPSILON);
!         AnimationShim.finished(t0);
  
          // only to-value set
          node.setRotate(originalAngle);
          t0.setFromAngle(Double.NaN);
          t0.setToAngle(toAngle);
          t0.setByAngle(0.0);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(originalAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(toAngle, node.getRotate(), EPSILON);
!         AnimationShim.finished(t0);
  
          // only by-value set
          node.setRotate(originalAngle);
          t0.setFromAngle(Double.NaN);
          t0.setToAngle(Double.NaN);
          t0.setByAngle(byAngle);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(originalAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(originalAngle + byAngle, node.getRotate(), EPSILON);
!         AnimationShim.finished(t0);
  
          // from- and to-values set
          node.setRotate(originalAngle);
          t0.setFromAngle(fromAngle);
          t0.setToAngle(toAngle);
          t0.setByAngle(0.0);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(fromAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(toAngle, node.getRotate(), EPSILON);
!         AnimationShim.finished(t0);
  
          // from- and by-values set
          node.setRotate(originalAngle);
          t0.setFromAngle(fromAngle);
          t0.setToAngle(Double.NaN);
          t0.setByAngle(byAngle);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(fromAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(fromAngle + byAngle, node.getRotate(), EPSILON);
!         AnimationShim.finished(t0);
  
          // to- and by-values set
          node.setRotate(originalAngle);
          t0.setFromAngle(Double.NaN);
          t0.setToAngle(toAngle);
          t0.setByAngle(byAngle);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(originalAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(toAngle, node.getRotate(), EPSILON);
!         AnimationShim.finished(t0);
  
          // all values set
          node.setRotate(originalAngle);
          t0.setFromAngle(fromAngle);
          t0.setToAngle(toAngle);
          t0.setByAngle(byAngle);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(fromAngle, node.getRotate(), EPSILON);
          TransitionShim.interpolate(t0,1.0);
          assertEquals(toAngle, node.getRotate(), EPSILON);
!         AnimationShim.finished(t0);
      }
  
      @Test
      public void testGetTargetNode() {
          final RotateTransition rt = new RotateTransition(ONE_SEC, node);
*** 291,408 ****
          final ParallelTransition pt = new ParallelTransition();
          pt.getChildren().add(rt);
          pt.setNode(node2);
  
          // node set, parent set
!         assertTrue(AnimationShim.impl_startable(rt,true));
!         AnimationShim.impl_start(rt,true);
          TransitionShim.interpolate(rt,0.5);
          assertEquals(0.75, node.getRotate(), EPSILON);
          assertEquals(0.0, node2.getRotate(), EPSILON);
!         AnimationShim.impl_finished(rt);
  
          // node null, parent set
          rt.setNode(null);
!         assertTrue(AnimationShim.impl_startable(rt,true));
!         AnimationShim.impl_start(rt,true);
          TransitionShim.interpolate(rt,0.4);
          assertEquals(0.75, node.getRotate(), EPSILON);
          assertEquals(0.7, node2.getRotate(), EPSILON);
!         AnimationShim.impl_finished(rt);
  
          // node null, parent null
          pt.setNode(null);
!         assertFalse(AnimationShim.impl_startable(rt,true));
      }
  
      @Test
      public void testCachedValues() {
          final RotateTransition rt = new RotateTransition(ONE_SEC, node);
          rt.setInterpolator(Interpolator.LINEAR);
          rt.setFromAngle(0.5);
          rt.setToAngle(1.0);
  
          // start
!         assertTrue(AnimationShim.impl_startable(rt,true));
!         AnimationShim.impl_start(rt,true);
          rt.setFromAngle(0.0);
          TransitionShim.interpolate(rt,0.5);
          assertEquals(0.75, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(rt);
          rt.setFromAngle(0.5);
  
          // end
!         assertTrue(AnimationShim.impl_startable(rt,true));
!         AnimationShim.impl_start(rt,true);
          rt.setToAngle(0.0);
          TransitionShim.interpolate(rt,0.2);
          assertEquals(0.6, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(rt);
          rt.setToAngle(1.0);
  
          // node
!         assertTrue(AnimationShim.impl_startable(rt,true));
!         AnimationShim.impl_start(rt,true);
          rt.setNode(null);
          TransitionShim.interpolate(rt,0.7);
          assertEquals(0.85, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(rt);
          rt.setNode(node);
  
          // interpolator
!         assertTrue(AnimationShim.impl_startable(rt,true));
!         AnimationShim.impl_start(rt,true);
          rt.setInterpolator(null);
          TransitionShim.interpolate(rt,0.1);
          assertEquals(0.55, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(rt);
          rt.setInterpolator(Interpolator.LINEAR);
      }
  
      @Test
      public void testStartable() {
          final RotateTransition t0 = new RotateTransition(Duration.ONE, node);
!         assertTrue(AnimationShim.impl_startable(t0,true));
  
          // duration is 0
          t0.setDuration(Duration.ZERO);
!         assertFalse(AnimationShim.impl_startable(t0,true));
          t0.setDuration(Duration.ONE);
!         assertTrue(AnimationShim.impl_startable(t0,true));
  
          // node is null
          t0.setNode(null);
!         assertFalse(AnimationShim.impl_startable(t0,true));
          t0.setNode(node);
!         assertTrue(AnimationShim.impl_startable(t0,true));
  
          // interpolator is null
          t0.setInterpolator(null);
!         assertFalse(AnimationShim.impl_startable(t0,true));
          t0.setInterpolator(Interpolator.LINEAR);
!         assertTrue(AnimationShim.impl_startable(t0,true));
      }
  
      @Test
      public void testEvaluateStartValue() {
          final RotateTransition t0 = new RotateTransition(Duration.INDEFINITE, node);
  
          // first run
          node.setRotate(0.6);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          node.setRotate(0.8);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(0.6, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(t0);
  
          // second run
          node.setRotate(0.2);
!         assertTrue(AnimationShim.impl_startable(t0,true));
!         AnimationShim.impl_start(t0,true);
          node.setRotate(0.8);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(0.2, node.getRotate(), EPSILON);
!         AnimationShim.impl_finished(t0);
      }
  
  }
--- 291,408 ----
          final ParallelTransition pt = new ParallelTransition();
          pt.getChildren().add(rt);
          pt.setNode(node2);
  
          // node set, parent set
!         assertTrue(AnimationShim.startable(rt,true));
!         AnimationShim.doStart(rt,true);
          TransitionShim.interpolate(rt,0.5);
          assertEquals(0.75, node.getRotate(), EPSILON);
          assertEquals(0.0, node2.getRotate(), EPSILON);
!         AnimationShim.finished(rt);
  
          // node null, parent set
          rt.setNode(null);
!         assertTrue(AnimationShim.startable(rt,true));
!         AnimationShim.doStart(rt,true);
          TransitionShim.interpolate(rt,0.4);
          assertEquals(0.75, node.getRotate(), EPSILON);
          assertEquals(0.7, node2.getRotate(), EPSILON);
!         AnimationShim.finished(rt);
  
          // node null, parent null
          pt.setNode(null);
!         assertFalse(AnimationShim.startable(rt,true));
      }
  
      @Test
      public void testCachedValues() {
          final RotateTransition rt = new RotateTransition(ONE_SEC, node);
          rt.setInterpolator(Interpolator.LINEAR);
          rt.setFromAngle(0.5);
          rt.setToAngle(1.0);
  
          // start
!         assertTrue(AnimationShim.startable(rt,true));
!         AnimationShim.doStart(rt,true);
          rt.setFromAngle(0.0);
          TransitionShim.interpolate(rt,0.5);
          assertEquals(0.75, node.getRotate(), EPSILON);
!         AnimationShim.finished(rt);
          rt.setFromAngle(0.5);
  
          // end
!         assertTrue(AnimationShim.startable(rt,true));
!         AnimationShim.doStart(rt,true);
          rt.setToAngle(0.0);
          TransitionShim.interpolate(rt,0.2);
          assertEquals(0.6, node.getRotate(), EPSILON);
!         AnimationShim.finished(rt);
          rt.setToAngle(1.0);
  
          // node
!         assertTrue(AnimationShim.startable(rt,true));
!         AnimationShim.doStart(rt,true);
          rt.setNode(null);
          TransitionShim.interpolate(rt,0.7);
          assertEquals(0.85, node.getRotate(), EPSILON);
!         AnimationShim.finished(rt);
          rt.setNode(node);
  
          // interpolator
!         assertTrue(AnimationShim.startable(rt,true));
!         AnimationShim.doStart(rt,true);
          rt.setInterpolator(null);
          TransitionShim.interpolate(rt,0.1);
          assertEquals(0.55, node.getRotate(), EPSILON);
!         AnimationShim.finished(rt);
          rt.setInterpolator(Interpolator.LINEAR);
      }
  
      @Test
      public void testStartable() {
          final RotateTransition t0 = new RotateTransition(Duration.ONE, node);
!         assertTrue(AnimationShim.startable(t0,true));
  
          // duration is 0
          t0.setDuration(Duration.ZERO);
!         assertFalse(AnimationShim.startable(t0,true));
          t0.setDuration(Duration.ONE);
!         assertTrue(AnimationShim.startable(t0,true));
  
          // node is null
          t0.setNode(null);
!         assertFalse(AnimationShim.startable(t0,true));
          t0.setNode(node);
!         assertTrue(AnimationShim.startable(t0,true));
  
          // interpolator is null
          t0.setInterpolator(null);
!         assertFalse(AnimationShim.startable(t0,true));
          t0.setInterpolator(Interpolator.LINEAR);
!         assertTrue(AnimationShim.startable(t0,true));
      }
  
      @Test
      public void testEvaluateStartValue() {
          final RotateTransition t0 = new RotateTransition(Duration.INDEFINITE, node);
  
          // first run
          node.setRotate(0.6);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          node.setRotate(0.8);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(0.6, node.getRotate(), EPSILON);
!         AnimationShim.finished(t0);
  
          // second run
          node.setRotate(0.2);
!         assertTrue(AnimationShim.startable(t0,true));
!         AnimationShim.doStart(t0,true);
          node.setRotate(0.8);
          TransitionShim.interpolate(t0,0.0);
          assertEquals(0.2, node.getRotate(), EPSILON);
!         AnimationShim.finished(t0);
      }
  
  }