Merge "Move memory pool class internal" into tizen

[platform/core/uifw/dali-core.git] / automated-tests / src / dali / utc-Dali-Animation.cpp

diff --git a/automated-tests/src/dali/utc-Dali-Animation.cpp b/automated-tests/src/dali/utc-Dali-Animation.cpp
index 8d77d41..a4917db 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-Animation.cpp
+++ b/automated-tests/src/dali/utc-Dali-Animation.cpp
@@ -88,132 +88,6 @@ struct AnimationFinishCheck
   bool& mSignalReceived; // owned by individual tests
 };
 
-static bool ReturnFalseAfterProgressOne( float alpha, const bool& current )
-{
-  return alpha < 1.0f;
-}
-
-struct AnimateFloatTestFunctor
-{
-  AnimateFloatTestFunctor( float start, float end )
-  : mStart( start ),
-    mEnd( end )
-  {
-  }
-
-  float operator()( float alpha, const float& current )
-  {
-    return mStart + ((mEnd - mStart) * alpha );
-  }
-
-  float mStart;
-  float mEnd;
-};
-
-struct AnimateIntegerTestFunctor
-{
-  AnimateIntegerTestFunctor( int start, int end )
-  : mStart( start ),
-    mEnd( end )
-  {
-  }
-
-  int operator()( float alpha, const int& current )
-  {
-    return static_cast<int>( mStart + ((mEnd - mStart) * alpha ) + 0.5f );
-  }
-
-  int mStart;
-  int mEnd;
-};
-
-struct AnimateVector2TestFunctor
-{
-  AnimateVector2TestFunctor( Vector2 start, Vector2 end )
-  : mStart( start ),
-    mEnd( end )
-  {
-  }
-
-  Vector2 operator()( float alpha, const Vector2& current )
-  {
-    return mStart + ((mEnd - mStart) * alpha );
-  }
-
-  Vector2 mStart;
-  Vector2 mEnd;
-};
-
-struct AnimateVector4TestFunctor
-{
-  AnimateVector4TestFunctor( Vector4 start, Vector4 end )
-  : mStart( start ),
-    mEnd( end )
-  {
-  }
-
-  Vector4 operator()( float alpha, const Vector4& current )
-  {
-    return mStart + ((mEnd - mStart) * alpha );
-  }
-
-  Vector4 mStart;
-  Vector4 mEnd;
-};
-
-struct AnimateQuaternionTestFunctor
-{
-  AnimateQuaternionTestFunctor( Quaternion start, Quaternion end )
-  : mStart( start ),
-    mEnd( end )
-  {
-  }
-
-  Quaternion operator()( float alpha, const Quaternion& current )
-  {
-    return Quaternion::Slerp(mStart, mEnd, alpha);
-  }
-
-  Quaternion mStart;
-  Quaternion mEnd;
-};
-
-struct BounceFunc
-{
-  BounceFunc(float x, float y, float z)
-  : mDistance(Vector3(x, y, z))
-  {
-  }
-  Vector3 operator()(float alpha, const Vector3& current)
-  {
-    if (alpha>0.001f && alpha<1.0f)
-    {
-      const float flip = 0.5f - cosf(alpha * Math::PI * 2.0f) * 0.5f;
-      Vector3 newTranslation(current);
-      newTranslation += mDistance * flip;
-      return newTranslation;
-    }
-    return current;
-  }
-  Vector3 mDistance;
-};
-
-
-struct TumbleFunc
-{
-  TumbleFunc(Vector3 axis) : tumbleAxis(axis){}
-  Quaternion operator()(float alpha, const Quaternion& current)
-  {
-    if (alpha>0.001f && alpha<1.0f)
-    {
-      Quaternion tumbleRotation(alpha * Math::PI * 2.0f, tumbleAxis);
-      return tumbleRotation * current;
-    }
-    return current;
-  }
-  Vector3 tumbleAxis;
-};
-
 } // anon namespace
 
 int UtcDaliAnimationNew01(void)
@@ -241,12 +115,9 @@ int UtcDaliAnimationNew02(void)
   }
   catch (Dali::DaliException& e)
   {
-    // TODO: Determine why catch doesn't.
-    //
-
     // Tests that a negative test of an assertion succeeds
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
-    DALI_TEST_EQUALS(e.mCondition, "durationSeconds > 0.0f", TEST_LOCATION);
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_EQUALS(e.condition, "durationSeconds > 0.0f", TEST_LOCATION);
   }
   END_TEST;
 }
@@ -530,17 +401,129 @@ int UtcDaliAnimationGetEndAction(void)
   END_TEST;
 }
 
-int UtcDaliAnimationGetDestroyAction(void)
+int UtcDaliAnimationSetDisconnectAction(void)
+{
+  TestApplication application;
+  Stage stage( Stage::GetCurrent() );
+
+  // Default: BakeFinal
+  {
+    Actor actor = Actor::New();
+    stage.Add(actor);
+
+    // Build the animation
+    float durationSeconds(1.0f);
+    Animation animation = Animation::New(durationSeconds);
+    DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::BakeFinal);
+
+    Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+    animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear);
+
+    // Start the animation
+    animation.Play();
+
+    application.SendNotification();
+    application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
+
+    actor.Unparent();
+
+    application.SendNotification();
+    application.Render();
+
+    DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
+  }
+
+  // Bake
+  {
+    Actor actor = Actor::New();
+    stage.Add(actor);
+
+    // Build the animation
+    float durationSeconds(1.0f);
+    Animation animation = Animation::New(durationSeconds);
+    animation.SetDisconnectAction( Animation::Bake );
+
+    Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+    animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear);
+
+    // Start the animation
+    animation.Play();
+
+    application.SendNotification();
+    application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
+
+    actor.Unparent();
+
+    application.SendNotification();
+    application.Render();
+
+    DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition*0.5f, TEST_LOCATION );
+  }
+
+  // Discard
+  {
+    Actor actor = Actor::New();
+    stage.Add(actor);
+
+    // Build the animation
+    float durationSeconds(1.0f);
+    Animation animation = Animation::New(durationSeconds);
+    animation.SetDisconnectAction( Animation::Discard );
+
+    Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+    animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear);
+
+    // Start the animation
+    animation.Play();
+
+    application.SendNotification();
+    application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
+
+    actor.Unparent();
+
+    application.SendNotification();
+    application.Render();
+
+    DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
+  }
+
+  // Don't play the animation: disconnect action should not be applied
+  {
+    Actor actor = Actor::New();
+    stage.Add(actor);
+
+    // Build the animation
+    float durationSeconds(1.0f);
+    Animation animation = Animation::New(durationSeconds);
+
+    Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+    animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear);
+
+    application.SendNotification();
+    application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
+
+    actor.Unparent();
+
+    application.SendNotification();
+    application.Render();
+
+    DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int UtcDaliAnimationGetDisconnectAction(void)
 {
   TestApplication application;
   Animation animation = Animation::New(1.0f);
-  DALI_TEST_CHECK(animation.GetDestroyAction() == Animation::Bake); // default!
+  DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::BakeFinal); // default!
 
-  animation.SetDestroyAction(Animation::Discard);
-  DALI_TEST_CHECK(animation.GetDestroyAction() == Animation::Discard);
+  animation.SetDisconnectAction(Animation::Discard);
+  DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::Discard);
 
-  animation.SetDestroyAction(Animation::BakeFinal);
-  DALI_TEST_CHECK(animation.GetDestroyAction() == Animation::BakeFinal);
+  animation.SetDisconnectAction(Animation::Bake);
+  DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::Bake);
 
   END_TEST;
 }
@@ -643,24 +626,27 @@ int UtcDaliAnimationPlay(void)
   END_TEST;
 }
 
-int UtcDaliAnimationPlayOffStage(void)
+int UtcDaliAnimationSetSpeedFactor(void)
 {
-  // Test that an animation can be played, when the actor is off-stage.
-  // When the actor is added to the stage, it should appear at the current position
-  // i.e. where it would have been anyway, if on-stage from the beginning.
-
   TestApplication application;
 
   Actor actor = Actor::New();
-  Vector3 basePosition(Vector3::ZERO);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), basePosition, TEST_LOCATION );
-  // Not added to the stage!
+  Stage::GetCurrent().Add(actor);
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
-  Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear);
+
+  const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
+  const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+
+  KeyFrames keyframes = KeyFrames::New();
+  keyframes.Add( 0.0f, initialPosition);
+  keyframes.Add( 1.0f, targetPosition );
+  animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunctions::Linear);
+
+  //Set speed to be x2
+  animation.SetSpeedFactor(2.0f);
 
   // Start the animation
   animation.Play();
@@ -670,147 +656,170 @@ int UtcDaliAnimationPlayOffStage(void)
   animation.FinishedSignal().Connect(&application, finishCheck);
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*off-stage*/, TEST_LOCATION );
-
-  // Add to the stage
-  Stage::GetCurrent().Add(actor);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
 
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  Vector3 expectedPosition(basePosition + (targetPosition - basePosition)*0.4f);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), expectedPosition/*on-stage*/, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
 
-  // Remove from the stage
-  Stage::GetCurrent().Remove(actor);
+  application.Render(static_cast<unsigned int>(durationSeconds*100.0f) + 1u/*just beyond half the duration*/);
 
+  // We did expect the animation to finish
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+  finishCheck.CheckSignalReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
+
+  // Check that nothing has changed after a couple of buffer swaps
+  application.Render(0);
+  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
+  application.Render(0);
+  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
+
+  finishCheck.Reset();
+
+  //Test -1 speed factor. Animation will play in reverse at normal speed
+  animation.SetSpeedFactor( -1.0f );
+
+  // Start the animation
+  animation.Play();
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*back to start position*/, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
 
-  // Add to the stage
-  Stage::GetCurrent().Add(actor);
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
 
+  // We didn't expect the animation to finish yet
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  expectedPosition = Vector3(basePosition + (targetPosition - basePosition)*0.8f);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), expectedPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
 
+  // We didn't expect the animation to finish yet
   application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
+
   application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
 
   // We did expect the animation to finish
   application.SendNotification();
   finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
 
   // Check that nothing has changed after a couple of buffer swaps
   application.Render(0);
-  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
+  DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
   application.Render(0);
-  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimationPlayDiscardHandle(void)
-{
-  TestApplication application;
+  DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 
-  Actor actor = Actor::New();
-  Stage::GetCurrent().Add(actor);
 
-  // Build the animation
-  float durationSeconds(1.0f);
-  Animation animation = Animation::New(durationSeconds);
-  Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear);
+  //Test change speed factor on the fly
+  finishCheck.Reset();
 
-  bool signalReceived(false);
-  AnimationFinishCheck finishCheck(signalReceived);
-  animation.FinishedSignal().Connect(&application, finishCheck);
+  //Set speed to be half of normal speed
+  animation.SetSpeedFactor( 0.5f );
 
   // Start the animation
   animation.Play();
 
-  // This is a test of the "Fire and Forget" behaviour
-  // Discard the animation handle!
-  animation.Reset();
-  DALI_TEST_CHECK( !animation );
-
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.1f), TEST_LOCATION );
 
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
 
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.3f), TEST_LOCATION );
 
+  //Change speed factor while animation still playing.
+  animation.SetSpeedFactor(-1.0f);
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.1f), TEST_LOCATION );
 
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+  application.Render(static_cast<unsigned int>(durationSeconds*100.0f) + 1u/*just beyond the animation duration*/);
 
   // We did expect the animation to finish
   application.SendNotification();
   finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
 
   // Check that nothing has changed after a couple of buffer swaps
   application.Render(0);
-  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
+  DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
   application.Render(0);
-  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
+  DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
   END_TEST;
 }
 
-int UtcDaliAnimationPlayStopDiscardHandle(void)
+int UtcDaliAnimationGetSpeedFactor(void)
+{
+  TestApplication application;
+
+  Animation animation = Animation::New(1.0f);
+  animation.SetSpeedFactor(0.5f);
+  DALI_TEST_EQUALS(animation.GetSpeedFactor(), 0.5f, TEST_LOCATION);
+
+  animation.SetSpeedFactor(-2.5f);
+  DALI_TEST_EQUALS(animation.GetSpeedFactor(), -2.5f, TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliAnimationPlayOffStage(void)
 {
+  // Test that an animation can be played, when the actor is off-stage.
+  // When the actor is added to the stage, it should appear at the current position
+  // i.e. where it would have been anyway, if on-stage from the beginning.
+
   TestApplication application;
 
   Actor actor = Actor::New();
-  Stage::GetCurrent().Add(actor);
+  Vector3 basePosition(Vector3::ZERO);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), basePosition, TEST_LOCATION );
+  // Not added to the stage!
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
+  animation.SetDisconnectAction( Animation::Discard );
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
   animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear);
 
@@ -827,10 +836,162 @@ int UtcDaliAnimationPlayStopDiscardHandle(void)
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*off-stage*/, TEST_LOCATION );
 
-  // This is a test of the "Fire and Forget" behaviour
-  // Stop the animation, and Discard the animation handle!
+  // Add to the stage
+  Stage::GetCurrent().Add(actor);
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  Vector3 expectedPosition(basePosition + (targetPosition - basePosition)*0.4f);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), expectedPosition/*on-stage*/, TEST_LOCATION );
+
+  // Remove from the stage
+  Stage::GetCurrent().Remove(actor);
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*back to start position*/, TEST_LOCATION );
+
+  // Add to the stage
+  Stage::GetCurrent().Add(actor);
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  expectedPosition = Vector3(basePosition + (targetPosition - basePosition)*0.8f);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), expectedPosition, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+
+  // We did expect the animation to finish
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
+
+  // Check that nothing has changed after a couple of buffer swaps
+  application.Render(0);
+  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
+  application.Render(0);
+  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliAnimationPlayDiscardHandle(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  Stage::GetCurrent().Add(actor);
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+  Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+  animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear);
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  // Start the animation
+  animation.Play();
+
+  // This is a test of the "Fire and Forget" behaviour
+  // Discard the animation handle!
+  animation.Reset();
+  DALI_TEST_CHECK( !animation );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+
+  // We did expect the animation to finish
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
+
+  // Check that nothing has changed after a couple of buffer swaps
+  application.Render(0);
+  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
+  application.Render(0);
+  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliAnimationPlayStopDiscardHandle(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  Stage::GetCurrent().Add(actor);
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+  Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+  animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear);
+
+  // Start the animation
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
+
+  // This is a test of the "Fire and Forget" behaviour
+  // Stop the animation, and Discard the animation handle!
   animation.Stop();
   animation.Reset();
   DALI_TEST_CHECK( !animation );
@@ -1017,6 +1178,144 @@ int UtcDaliAnimationSetCurrentProgress(void)
   END_TEST;
 }
 
+int UtcDaliAnimationPlayRange(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  Stage::GetCurrent().Add(actor);
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+  Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+  KeyFrames keyframes = KeyFrames::New();
+  keyframes.Add( 0.0f , Vector3(0.0f,0.0f,0.0f ) );
+  keyframes.Add( 1.0f , Vector3(100.0f,100.0f,100.0f ) );
+
+  animation.AnimateBetween( Property( actor, Actor::Property::POSITION), keyframes );
+
+  // Set range between 0.4 and 0.8
+  animation.SetPlayRange( Vector2(0.4f,0.8f) );
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  //Test that setting progress outside the range doesn't work
+  animation.SetCurrentProgress( 0.9f );
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_EQUALS( animation.GetCurrentProgress(), 0.4f, TEST_LOCATION );
+  animation.SetCurrentProgress( 0.2f );
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_EQUALS( animation.GetCurrentProgress(), 0.4f, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
+
+  animation.Play(); // Test that calling play has no effect, when animation is already playing
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/* 80% progress */);
+
+  // We did expect the animation to finish
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
+
+  // Check that nothing has changed after a couple of buffer swaps
+  application.Render(0);
+  DALI_TEST_EQUALS( targetPosition * 0.8f, actor.GetCurrentPosition(), TEST_LOCATION );
+  application.Render(0);
+  DALI_TEST_EQUALS( targetPosition * 0.8f, actor.GetCurrentPosition(), TEST_LOCATION );
+
+
+  //Loop inside the range
+  finishCheck.Reset();
+  animation.SetLooping( true );
+  animation.Play();
+  application.SendNotification();
+  float intervalSeconds = 0.1f;
+  float progress = 0.4f;
+  for (int iterations = 0; iterations < 10; ++iterations )
+  {
+    application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+
+    progress += intervalSeconds;
+    if (progress > 0.8f)
+    {
+      progress = progress - 0.4f;
+    }
+
+    DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentPosition(), 0.001f, TEST_LOCATION );
+  }
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+
+  //Test change range on the fly
+  animation.SetPlayRange( Vector2( 0.2f, 0.9f ) );
+  application.SendNotification();
+
+  for (int iterations = 0; iterations < 10; ++iterations )
+  {
+    application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+
+    progress += intervalSeconds;
+    if (progress > 0.9f)
+    {
+      progress = progress - 0.7f;
+    }
+
+    DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentPosition(), 0.001f, TEST_LOCATION );
+  }
+
+  END_TEST;
+}
+
+int UtcDaliAnimationSetPlayRange(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  Stage::GetCurrent().Add(actor);
+
+  // Build the animation
+  Animation animation = Animation::New(0);
+  application.SendNotification();
+
+  //If PlayRange not specified it should be 0.0-1.0 by default
+  DALI_TEST_EQUALS( Vector2(0.0,1.0), animation.GetPlayRange(), TEST_LOCATION );
+
+  //PlayRange out of bounds
+  animation.SetPlayRange( Vector2(-1.0f,1.0f) );
+  application.SendNotification();
+  DALI_TEST_EQUALS( Vector2(0.0f,1.0f), animation.GetPlayRange(), TEST_LOCATION );
+  animation.SetPlayRange( Vector2(0.0f,2.0f) );
+  application.SendNotification();
+  DALI_TEST_EQUALS( Vector2(0.0f,1.0f), animation.GetPlayRange(), TEST_LOCATION );
+
+  //If playRange is not in the correct order it has to be ordered
+  animation.SetPlayRange( Vector2(0.8f,0.2f) );
+  application.SendNotification();
+  DALI_TEST_EQUALS( Vector2(0.2f,0.8f), animation.GetPlayRange(), TEST_LOCATION );
+
+  // Set range between 0.4 and 0.8
+  animation.SetPlayRange( Vector2(0.4f,0.8f) );
+  application.SendNotification();
+  DALI_TEST_EQUALS( Vector2(0.4f,0.8f), animation.GetPlayRange(), TEST_LOCATION );
+
+  END_TEST;
+}
 
 int UtcDaliAnimationPause(void)
 {
@@ -2736,7 +3035,7 @@ int UtcDaliAnimationAnimateByActorPosition(void)
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(20.0f, 20.0f, 20.0f);
   Vector3 relativePosition(targetPosition - startPosition);
-  animation.AnimateBy(Property(actor, Actor::POSITION), relativePosition);
+  animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition);
 
   Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
 
@@ -2788,7 +3087,7 @@ int UtcDaliAnimationAnimateByActorPositionAlphaFunction(void)
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(20.0f, 20.0f, 20.0f);
   Vector3 relativePosition(targetPosition - startPosition);
-  animation.AnimateBy(Property(actor, Actor::POSITION), relativePosition, AlphaFunctions::EaseOut);
+  animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition, AlphaFunctions::EaseOut);
 
   Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
 
@@ -2846,7 +3145,7 @@ int UtcDaliAnimationAnimateByActorPositionTimePeriod(void)
   Vector3 targetPosition(20.0f, 20.0f, 20.0f);
   Vector3 relativePosition(targetPosition - startPosition);
   float delay = 0.5f;
-  animation.AnimateBy(Property(actor, Actor::POSITION),
+  animation.AnimateBy(Property(actor, Actor::Property::POSITION),
                       relativePosition,
                       TimePeriod(delay, durationSeconds - delay));
 
@@ -2901,7 +3200,7 @@ int UtcDaliAnimationAnimateByActorPositionAlphaFunctionTimePeriod(void)
   Vector3 targetPosition(20.0f, 20.0f, 20.0f);
   Vector3 relativePosition(targetPosition - startPosition);
   float delay = 0.5f;
-  animation.AnimateBy(Property(actor, Actor::POSITION),
+  animation.AnimateBy(Property(actor, Actor::Property::POSITION),
                       relativePosition,
                       AlphaFunctions::Linear,
                       TimePeriod(delay, durationSeconds - delay));
@@ -4339,11 +4638,11 @@ int UtcDaliAnimationAnimateToActorParentOrigin(void)
 
   try
   {
-    animation.AnimateTo( Property(actor, Actor::PARENT_ORIGIN), targetParentOrigin );
+    animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN), targetParentOrigin );
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "IsPropertyAnimatable(index)", TEST_LOCATION);
   }
   END_TEST;
@@ -4357,7 +4656,7 @@ int UtcDaliAnimationAnimateToActorParentOriginX(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.0f);
   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin().x, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::PARENT_ORIGIN_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_X), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
@@ -4366,11 +4665,11 @@ int UtcDaliAnimationAnimateToActorParentOriginX(void)
 
   try
   {
-    animation.AnimateTo( Property(actor, Actor::PARENT_ORIGIN_X), targetX );
+    animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_X), targetX );
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "IsPropertyAnimatable(index)", TEST_LOCATION);
   }
   END_TEST;
@@ -4384,7 +4683,7 @@ int UtcDaliAnimationAnimateToActorParentOriginY(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.0f);
   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin().y, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::PARENT_ORIGIN_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_Y), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
@@ -4393,11 +4692,11 @@ int UtcDaliAnimationAnimateToActorParentOriginY(void)
 
   try
   {
-    animation.AnimateTo( Property(actor, Actor::PARENT_ORIGIN_Y), targetY );
+    animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_Y), targetY );
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "IsPropertyAnimatable(index)", TEST_LOCATION);
   }
   END_TEST;
@@ -4411,7 +4710,7 @@ int UtcDaliAnimationAnimateToActorParentOriginZ(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.5f);
   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin().z, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::PARENT_ORIGIN_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_Z), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
@@ -4420,11 +4719,11 @@ int UtcDaliAnimationAnimateToActorParentOriginZ(void)
 
   try
   {
-    animation.AnimateTo( Property(actor, Actor::PARENT_ORIGIN_Z), targetZ );
+    animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_Z), targetZ );
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "IsPropertyAnimatable(index)", TEST_LOCATION);
   }
   END_TEST;
@@ -4445,11 +4744,11 @@ int UtcDaliAnimationAnimateToActorAnchorPoint(void)
 
   try
   {
-    animation.AnimateTo( Property(actor, Actor::ANCHOR_POINT), targetAnchorPoint);
+    animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT), targetAnchorPoint);
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "IsPropertyAnimatable(index)", TEST_LOCATION);
   }
   END_TEST;
@@ -4463,7 +4762,7 @@ int UtcDaliAnimationAnimateToActorAnchorPointX(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.5f);
   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint().x, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::ANCHOR_POINT_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_X), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
@@ -4472,11 +4771,11 @@ int UtcDaliAnimationAnimateToActorAnchorPointX(void)
 
   try
   {
-    animation.AnimateTo( Property(actor, Actor::ANCHOR_POINT_X), targetX );
+    animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_X), targetX );
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "IsPropertyAnimatable(index)", TEST_LOCATION);
   }
   END_TEST;
@@ -4490,7 +4789,7 @@ int UtcDaliAnimationAnimateToActorAnchorPointY(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.5f);
   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint().y, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::ANCHOR_POINT_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_Y), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
@@ -4499,11 +4798,11 @@ int UtcDaliAnimationAnimateToActorAnchorPointY(void)
 
   try
   {
-    animation.AnimateTo( Property(actor, Actor::ANCHOR_POINT_Y), targetY );
+    animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_Y), targetY );
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "IsPropertyAnimatable(index)", TEST_LOCATION);
   }
   END_TEST;
@@ -4517,7 +4816,7 @@ int UtcDaliAnimationAnimateToActorAnchorPointZ(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.5f);
   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint().z, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::ANCHOR_POINT_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_Z), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
@@ -4526,11 +4825,11 @@ int UtcDaliAnimationAnimateToActorAnchorPointZ(void)
 
   try
   {
-    animation.AnimateTo( Property(actor, Actor::ANCHOR_POINT_Z), targetZ );
+    animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_Z), targetZ );
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "IsPropertyAnimatable(index)", TEST_LOCATION);
   }
   END_TEST;
@@ -4548,7 +4847,7 @@ int UtcDaliAnimationAnimateToActorSize(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetSize(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo( Property(actor, Actor::SIZE), targetSize );
+  animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize );
 
   Vector3 ninetyNinePercentProgress(targetSize * 0.99f);
 
@@ -4584,7 +4883,7 @@ int UtcDaliAnimationAnimateToActorSize(void)
 
   // Repeat with a different (ease-in) alpha function
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::SIZE), targetSize, AlphaFunctions::EaseIn);
+  animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunctions::EaseIn);
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -4622,7 +4921,7 @@ int UtcDaliAnimationAnimateToActorSize(void)
   // Repeat with a delay
   float delay = 0.5f;
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::SIZE), targetSize, AlphaFunctions::Linear, TimePeriod(delay, durationSeconds - delay));
+  animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunctions::Linear, TimePeriod(delay, durationSeconds - delay));
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -4652,13 +4951,13 @@ int UtcDaliAnimationAnimateToActorSizeWidth(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.0f);
   DALI_TEST_EQUALS( actor.GetCurrentSize().width, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SIZE_WIDTH), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetWidth(10.0f);
-  animation.AnimateTo( Property(actor, Actor::SIZE_WIDTH), targetWidth );
+  animation.AnimateTo( Property(actor, Actor::Property::SIZE_WIDTH), targetWidth );
 
   float fiftyPercentProgress(startValue + (targetWidth - startValue)*0.5f);
 
@@ -4676,7 +4975,7 @@ int UtcDaliAnimationAnimateToActorSizeWidth(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentSize().width, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SIZE_WIDTH), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), fiftyPercentProgress, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -4685,7 +4984,7 @@ int UtcDaliAnimationAnimateToActorSizeWidth(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentSize().width, targetWidth, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SIZE_WIDTH), targetWidth, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetWidth, TEST_LOCATION );
   END_TEST;
 }
 
@@ -4697,13 +4996,13 @@ int UtcDaliAnimationAnimateToActorSizeHeight(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.0f);
   DALI_TEST_EQUALS( actor.GetCurrentSize().height, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SIZE_HEIGHT), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetHeight(-10.0f);
-  animation.AnimateTo( Property(actor, Actor::SIZE_HEIGHT), targetHeight );
+  animation.AnimateTo( Property(actor, Actor::Property::SIZE_HEIGHT), targetHeight );
 
   float fiftyPercentProgress(startValue + (targetHeight - startValue)*0.5f);
 
@@ -4721,7 +5020,7 @@ int UtcDaliAnimationAnimateToActorSizeHeight(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentSize().height, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SIZE_HEIGHT), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), fiftyPercentProgress, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -4730,7 +5029,7 @@ int UtcDaliAnimationAnimateToActorSizeHeight(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentSize().height, targetHeight, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SIZE_HEIGHT), targetHeight, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetHeight, TEST_LOCATION );
   END_TEST;
 }
 
@@ -4742,13 +5041,13 @@ int UtcDaliAnimationAnimateToActorSizeDepth(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.0f);
   DALI_TEST_EQUALS( actor.GetCurrentSize().depth, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SIZE_DEPTH), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetDepth(-10.0f);
-  animation.AnimateTo( Property(actor, Actor::SIZE_DEPTH), targetDepth );
+  animation.AnimateTo( Property(actor, Actor::Property::SIZE_DEPTH), targetDepth );
 
   float fiftyPercentProgress(startValue + (targetDepth - startValue)*0.5f);
 
@@ -4766,7 +5065,7 @@ int UtcDaliAnimationAnimateToActorSizeDepth(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentSize().depth, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SIZE_DEPTH), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), fiftyPercentProgress, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -4775,7 +5074,7 @@ int UtcDaliAnimationAnimateToActorSizeDepth(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentSize().depth, targetDepth, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SIZE_DEPTH), targetDepth, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetDepth, TEST_LOCATION );
   END_TEST;
 }
 
@@ -4791,7 +5090,7 @@ int UtcDaliAnimationAnimateToActorPosition(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(200.0f, 200.0f, 200.0f);
-  animation.AnimateTo(Property(actor, Actor::POSITION), targetPosition);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
 
   Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
 
@@ -4828,15 +5127,15 @@ int UtcDaliAnimationAnimateToActorPositionX(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.0f);
   DALI_TEST_EQUALS( actor.GetCurrentPosition().x, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetX(1.0f);
-  animation.AnimateTo( Property(actor, Actor::POSITION_X), targetX );
+  animation.AnimateTo( Property(actor, Actor::Property::POSITION_X), targetX );
 
   float fiftyPercentProgress(startValue + (targetX - startValue)*0.5f);
 
@@ -4854,9 +5153,9 @@ int UtcDaliAnimationAnimateToActorPositionX(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentPosition().x, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_X), fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -4865,9 +5164,9 @@ int UtcDaliAnimationAnimateToActorPositionX(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentPosition().x, targetX, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_X), targetX, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetX, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
   END_TEST;
 }
 
@@ -4879,15 +5178,15 @@ int UtcDaliAnimationAnimateToActorPositionY(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.0f);
   DALI_TEST_EQUALS( actor.GetCurrentPosition().y, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetY(10.0f);
-  animation.AnimateTo( Property(actor, Actor::POSITION_Y), targetY );
+  animation.AnimateTo( Property(actor, Actor::Property::POSITION_Y), targetY );
 
   float fiftyPercentProgress(startValue + (targetY - startValue)*0.5f);
 
@@ -4905,9 +5204,9 @@ int UtcDaliAnimationAnimateToActorPositionY(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentPosition().y, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Y), fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -4916,9 +5215,9 @@ int UtcDaliAnimationAnimateToActorPositionY(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentPosition().y, targetY, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Y), targetY, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetY, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
   END_TEST;
 }
 
@@ -4930,15 +5229,15 @@ int UtcDaliAnimationAnimateToActorPositionZ(void)
   Stage::GetCurrent().Add(actor);
   float startValue(0.0f);
   DALI_TEST_EQUALS( actor.GetCurrentPosition().z, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetZ(-5.0f);
-  animation.AnimateTo( Property(actor, Actor::POSITION_Z), targetZ );
+  animation.AnimateTo( Property(actor, Actor::Property::POSITION_Z), targetZ );
 
   float fiftyPercentProgress(startValue + (targetZ - startValue)*0.5f);
 
@@ -4956,9 +5255,9 @@ int UtcDaliAnimationAnimateToActorPositionZ(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentPosition().z, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Z), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), fiftyPercentProgress, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -4967,9 +5266,9 @@ int UtcDaliAnimationAnimateToActorPositionZ(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentPosition().z, targetZ, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::POSITION_Z), targetZ, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetZ, TEST_LOCATION );
   END_TEST;
 }
 
@@ -4985,7 +5284,7 @@ int UtcDaliAnimationAnimateToActorPositionAlphaFunction(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(200.0f, 200.0f, 200.0f);
-  animation.AnimateTo(Property(actor, Actor::POSITION), targetPosition, AlphaFunctions::EaseIn);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::EaseIn);
 
   Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
 
@@ -5035,7 +5334,7 @@ int UtcDaliAnimationAnimateToActorPositionTimePeriod(void)
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(200.0f, 200.0f, 200.0f);
   float delay = 0.5f;
-  animation.AnimateTo( Property(actor, Actor::POSITION),
+  animation.AnimateTo( Property(actor, Actor::Property::POSITION),
                        targetPosition,
                        TimePeriod( delay, durationSeconds - delay ) );
 
@@ -5087,7 +5386,7 @@ int UtcDaliAnimationAnimateToActorPositionAlphaFunctionTimePeriod(void)
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(200.0f, 200.0f, 200.0f);
   float delay = 0.5f;
-  animation.AnimateTo( Property(actor, Actor::POSITION),
+  animation.AnimateTo( Property(actor, Actor::Property::POSITION),
                        targetPosition,
                        AlphaFunctions::Linear,
                        TimePeriod( delay, durationSeconds - delay ) );
@@ -5141,7 +5440,7 @@ int UtcDaliAnimationAnimateToActorRotationAngleAxis(void)
   Animation animation = Animation::New(durationSeconds);
   Degree targetRotationDegrees(90.0f);
   Radian targetRotationRadians(targetRotationDegrees);
-  animation.AnimateTo( Property(actor, Actor::ROTATION), AngleAxis(targetRotationRadians, Vector3::YAXIS) );
+  animation.AnimateTo( Property(actor, Actor::Property::ROTATION), AngleAxis(targetRotationRadians, Vector3::YAXIS) );
 
   // Start the animation
   animation.Play();
@@ -5199,7 +5498,7 @@ int UtcDaliAnimationAnimateToActorRotationQuaternion(void)
   Degree targetRotationDegrees(90.0f);
   Radian targetRotationRadians(targetRotationDegrees);
   Quaternion targetRotation(targetRotationRadians, Vector3::YAXIS);
-  animation.AnimateTo( Property(actor, Actor::ROTATION), targetRotation );
+  animation.AnimateTo( Property(actor, Actor::Property::ROTATION), targetRotation );
 
   // Start the animation
   animation.Play();
@@ -5256,7 +5555,7 @@ int UtcDaliAnimationAnimateToActorRotationAlphaFunction(void)
   Animation animation = Animation::New(durationSeconds);
   Degree targetRotationDegrees(90.0f);
   Radian targetRotationRadians(targetRotationDegrees);
-  animation.AnimateTo( Property(actor, Actor::ROTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunctions::EaseIn);
+  animation.AnimateTo( Property(actor, Actor::Property::ROTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunctions::EaseIn);
 
   // Start the animation
   animation.Play();
@@ -5314,7 +5613,7 @@ int UtcDaliAnimationAnimateToActorRotationTimePeriod(void)
   Degree targetRotationDegrees(90.0f);
   Radian targetRotationRadians(targetRotationDegrees);
   float delay(0.1f);
-  animation.AnimateTo( Property(actor, Actor::ROTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), TimePeriod(delay, durationSeconds - delay));
+  animation.AnimateTo( Property(actor, Actor::Property::ROTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
   animation.Play();
@@ -5375,7 +5674,7 @@ int UtcDaliAnimationAnimateToActorRotationAlphaFunctionTimePeriod(void)
   Degree targetRotationDegrees(90.0f);
   Radian targetRotationRadians(targetRotationDegrees);
   float delay(0.1f);
-  animation.AnimateTo( Property(actor, Actor::ROTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunctions::EaseIn, TimePeriod(delay, durationSeconds - delay));
+  animation.AnimateTo( Property(actor, Actor::Property::ROTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunctions::EaseIn, TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
   animation.Play();
@@ -5433,7 +5732,7 @@ int UtcDaliAnimationAnimateToActorScale(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetScale(2.0f, 2.0f, 2.0f);
-  animation.AnimateTo( Property(actor, Actor::SCALE), targetScale );
+  animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale );
 
   Vector3 ninetyNinePercentProgress(Vector3::ONE + (targetScale - Vector3::ONE)*0.99f);
 
@@ -5469,7 +5768,7 @@ int UtcDaliAnimationAnimateToActorScale(void)
 
   // Repeat with a different (ease-in) alpha function
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::SCALE), targetScale, AlphaFunctions::EaseIn);
+  animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunctions::EaseIn);
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -5507,7 +5806,7 @@ int UtcDaliAnimationAnimateToActorScale(void)
   // Repeat with a delay
   float delay = 0.5f;
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::SCALE), targetScale, AlphaFunctions::Linear, TimePeriod(delay, durationSeconds - delay));
+  animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunctions::Linear, TimePeriod(delay, durationSeconds - delay));
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -5537,15 +5836,15 @@ int UtcDaliAnimationAnimateToActorScaleX(void)
   Stage::GetCurrent().Add(actor);
   float startValue(1.0f);
   DALI_TEST_EQUALS( actor.GetCurrentScale().x, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetX(10.0f);
-  animation.AnimateTo( Property(actor, Actor::SCALE_X), targetX );
+  animation.AnimateTo( Property(actor, Actor::Property::SCALE_X), targetX );
 
   float fiftyPercentProgress(startValue + (targetX - startValue)*0.5f);
 
@@ -5563,9 +5862,9 @@ int UtcDaliAnimationAnimateToActorScaleX(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentScale().x, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_X), fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -5574,9 +5873,9 @@ int UtcDaliAnimationAnimateToActorScaleX(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentScale().x, targetX, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_X), targetX, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), targetX, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
   END_TEST;
 }
 
@@ -5588,15 +5887,15 @@ int UtcDaliAnimationAnimateToActorScaleY(void)
   Stage::GetCurrent().Add(actor);
   float startValue(1.0f);
   DALI_TEST_EQUALS( actor.GetCurrentScale().y, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetY(1000.0f);
-  animation.AnimateTo( Property(actor, Actor::SCALE_Y), targetY );
+  animation.AnimateTo( Property(actor, Actor::Property::SCALE_Y), targetY );
 
   float fiftyPercentProgress(startValue + (targetY - startValue)*0.5f);
 
@@ -5614,9 +5913,9 @@ int UtcDaliAnimationAnimateToActorScaleY(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentScale().y, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Y), fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -5625,9 +5924,9 @@ int UtcDaliAnimationAnimateToActorScaleY(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentScale().y, targetY, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Y), targetY, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), targetY, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
   END_TEST;
 }
 
@@ -5639,15 +5938,15 @@ int UtcDaliAnimationAnimateToActorScaleZ(void)
   Stage::GetCurrent().Add(actor);
   float startValue(1.0f);
   DALI_TEST_EQUALS( actor.GetCurrentScale().z, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Z), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetZ(-1000.0f);
-  animation.AnimateTo( Property(actor, Actor::SCALE_Z), targetZ );
+  animation.AnimateTo( Property(actor, Actor::Property::SCALE_Z), targetZ );
 
   float fiftyPercentProgress(startValue + (targetZ - startValue)*0.5f);
 
@@ -5665,9 +5964,9 @@ int UtcDaliAnimationAnimateToActorScaleZ(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentScale().z, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Z), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), fiftyPercentProgress, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -5676,9 +5975,9 @@ int UtcDaliAnimationAnimateToActorScaleZ(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentScale().z, targetZ, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_X), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Y), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::SCALE_Z), targetZ, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), targetZ, TEST_LOCATION );
   END_TEST;
 }
 
@@ -5694,7 +5993,7 @@ int UtcDaliAnimationAnimateToActorColor(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector4 targetColor(Color::RED);
-  animation.AnimateTo( Property(actor, Actor::COLOR), targetColor );
+  animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor );
 
   Vector4 tenPercentProgress(Vector4(1.0f, 0.9f, 0.9f, 1.0f));
   Vector4 twentyPercentProgress(Vector4(1.0f, 0.8f, 0.8f, 1.0f));
@@ -5731,7 +6030,7 @@ int UtcDaliAnimationAnimateToActorColor(void)
 
   // Repeat with a different (ease-in) alpha function
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::COLOR), targetColor, AlphaFunctions::EaseIn);
+  animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunctions::EaseIn);
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -5769,7 +6068,7 @@ int UtcDaliAnimationAnimateToActorColor(void)
   // Repeat with a shorter animator duration
   float animatorDuration = 0.5f;
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::COLOR), targetColor, AlphaFunctions::Linear, TimePeriod(animatorDuration));
+  animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunctions::Linear, TimePeriod(animatorDuration));
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -5807,16 +6106,16 @@ int UtcDaliAnimationAnimateToActorColorRed(void)
   Stage::GetCurrent().Add(actor);
   float startValue(1.0f);
   DALI_TEST_EQUALS( actor.GetCurrentColor().r, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetRed(0.5f);
-  animation.AnimateTo( Property(actor, Actor::COLOR_RED), targetRed );
+  animation.AnimateTo( Property(actor, Actor::Property::COLOR_RED), targetRed );
 
   float fiftyPercentProgress(startValue + (targetRed - startValue)*0.5f);
 
@@ -5834,10 +6133,10 @@ int UtcDaliAnimationAnimateToActorColorRed(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentColor().r, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue,           TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue,           TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue,           TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -5846,10 +6145,10 @@ int UtcDaliAnimationAnimateToActorColorRed(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentColor().r, targetRed, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   targetRed,  TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   targetRed,  TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
   END_TEST;
 }
 
@@ -5861,16 +6160,16 @@ int UtcDaliAnimationAnimateToActorColorGreen(void)
   Stage::GetCurrent().Add(actor);
   float startValue(1.0f);
   DALI_TEST_EQUALS( actor.GetCurrentColor().g, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetGreen(0.5f);
-  animation.AnimateTo( Property(actor, Actor::COLOR_GREEN), targetGreen );
+  animation.AnimateTo( Property(actor, Actor::Property::COLOR_GREEN), targetGreen );
 
   float fiftyPercentProgress(startValue + (targetGreen - startValue)*0.5f);
 
@@ -5888,10 +6187,10 @@ int UtcDaliAnimationAnimateToActorColorGreen(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentColor().g, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue,           TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue,           TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue,           TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -5900,10 +6199,10 @@ int UtcDaliAnimationAnimateToActorColorGreen(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentColor().g, targetGreen, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue,  TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), targetGreen, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue,  TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue,  TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue,  TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), targetGreen, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue,  TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue,  TEST_LOCATION );
   END_TEST;
 }
 
@@ -5915,16 +6214,16 @@ int UtcDaliAnimationAnimateToActorColorBlue(void)
   Stage::GetCurrent().Add(actor);
   float startValue(1.0f);
   DALI_TEST_EQUALS( actor.GetCurrentColor().b, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetBlue(0.5f);
-  animation.AnimateTo( Property(actor, Actor::COLOR_BLUE), targetBlue );
+  animation.AnimateTo( Property(actor, Actor::Property::COLOR_BLUE), targetBlue );
 
   float fiftyPercentProgress(startValue + (targetBlue - startValue)*0.5f);
 
@@ -5942,10 +6241,10 @@ int UtcDaliAnimationAnimateToActorColorBlue(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentColor().b, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue,           TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue,           TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue,           TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -5954,10 +6253,10 @@ int UtcDaliAnimationAnimateToActorColorBlue(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentColor().b, targetBlue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  targetBlue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  targetBlue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
   END_TEST;
 }
 
@@ -5969,16 +6268,16 @@ int UtcDaliAnimationAnimateToActorColorAlpha(void)
   Stage::GetCurrent().Add(actor);
   float startValue(1.0f);
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   float targetAlpha(0.5f);
-  animation.AnimateTo( Property(actor, Actor::COLOR_ALPHA), targetAlpha );
+  animation.AnimateTo( Property(actor, Actor::Property::COLOR_ALPHA), targetAlpha );
 
   float fiftyPercentProgress(startValue + (targetAlpha - startValue)*0.5f);
 
@@ -5996,10 +6295,10 @@ int UtcDaliAnimationAnimateToActorColorAlpha(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, fiftyPercentProgress, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue,           TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue,           TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue,           TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), fiftyPercentProgress, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue,           TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), fiftyPercentProgress, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
@@ -6008,10 +6307,10 @@ int UtcDaliAnimationAnimateToActorColorAlpha(void)
   application.SendNotification();
   finishCheck.CheckSignalReceived();
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, targetAlpha, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue,  TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue,  TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue,  TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), targetAlpha, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue,  TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue,  TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue,  TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), targetAlpha, TEST_LOCATION );
   END_TEST;
 }
 
@@ -6039,7 +6338,7 @@ int UtcDaliAnimationKeyFrames01(void)
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
   }
   END_TEST;
@@ -6067,7 +6366,7 @@ int UtcDaliAnimationKeyFrames02(void)
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
   }
   END_TEST;
@@ -6096,7 +6395,7 @@ int UtcDaliAnimationKeyFrames03(void)
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
   }
   END_TEST;
@@ -6125,7 +6424,7 @@ int UtcDaliAnimationKeyFrames04(void)
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
   }
   END_TEST;
@@ -6153,7 +6452,7 @@ int UtcDaliAnimationKeyFrames05(void)
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
   }
   END_TEST;
@@ -6182,7 +6481,7 @@ int UtcDaliAnimationKeyFrames06(void)
   }
   catch (Dali::DaliException& e)
   {
-    tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
+    DALI_TEST_PRINT_ASSERT( e );
     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
   }
   END_TEST;
@@ -6202,10 +6501,10 @@ int UtcDaliAnimationAnimateBetweenActorColorAlpha(void)
   Stage::GetCurrent().Add(actor);
 
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
@@ -6219,7 +6518,7 @@ int UtcDaliAnimationAnimateBetweenActorColorAlpha(void)
   keyFrames.Add(0.8f, 0.7f);
   keyFrames.Add(1.0f, 0.9f);
 
-  animation.AnimateBetween( Property(actor, Actor::COLOR_ALPHA), keyFrames );
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR_ALPHA), keyFrames );
 
   // Start the animation
   animation.Play();
@@ -6235,50 +6534,50 @@ int UtcDaliAnimationAnimateBetweenActorColorAlpha(void)
 
   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.3f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.3f, 0.01f, TEST_LOCATION );
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.3f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.25f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.25f, 0.01f, TEST_LOCATION );
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.25f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 40% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.0f, 0.01f, TEST_LOCATION );
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.0f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 80% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.7f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7f, 0.01f, TEST_LOCATION );
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.7f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 90% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.8f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.8f, 0.01f, TEST_LOCATION );
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.8f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)+1/* 100% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.9f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.9f, 0.01f, TEST_LOCATION );
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.9f, 0.01f, TEST_LOCATION );
 
   // We did expect the animation to finish
@@ -6287,8 +6586,7 @@ int UtcDaliAnimationAnimateBetweenActorColorAlpha(void)
   END_TEST;
 }
 
-
-int UtcDaliAnimationAnimateBetweenActorColor(void)
+int UtcDaliAnimationAnimateBetweenActorColorAlphaCubic(void)
 {
   TestApplication application;
 
@@ -6298,21 +6596,191 @@ int UtcDaliAnimationAnimateBetweenActorColor(void)
   Stage::GetCurrent().Add(actor);
 
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
 
   KeyFrames keyFrames = KeyFrames::New();
-  keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
-  keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
-  keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
-
-  animation.AnimateBetween( Property(actor, Actor::COLOR), keyFrames );
+  keyFrames.Add(0.0f, 0.1f);
+  keyFrames.Add(0.2f, 0.5f);
+  keyFrames.Add(0.4f, 0.0f);
+  keyFrames.Add(0.6f, 1.0f);
+  keyFrames.Add(0.8f, 0.7f);
+  keyFrames.Add(1.0f, 0.9f);
+
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR_ALPHA), keyFrames, Animation::Cubic );
+
+  // Start the animation
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.1f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
+  application.SendNotification();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.36f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.36f, 0.01f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
+  application.SendNotification();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.21f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.21f, 0.01f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 40% progress */);
+  application.SendNotification();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.0f, 0.01f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 80% progress */);
+  application.SendNotification();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.7f, 0.01f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 90% progress */);
+  application.SendNotification();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.76f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.76f, 0.01f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*100.0f)+1/* 100% progress */);
+  application.SendNotification();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.9f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.9f, 0.01f, TEST_LOCATION );
+
+  // We did expect the animation to finish
+
+  finishCheck.CheckSignalReceived();
+  END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenActorColor(void)
+{
+  TestApplication application;
+
+  float startValue(1.0f);
+  Actor actor = Actor::New();
+  actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
+  Stage::GetCurrent().Add(actor);
+
+  DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+
+  KeyFrames keyFrames = KeyFrames::New();
+  keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
+  keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
+  keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
+
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames );
+
+  // Start the animation
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+  application.SendNotification();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+  application.SendNotification();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  application.SendNotification();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+  application.SendNotification();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
+
+  // We did expect the animation to finish
+
+  finishCheck.CheckSignalReceived();
+  END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenActorColorCubic(void)
+{
+  TestApplication application;
+
+  float startValue(1.0f);
+  Actor actor = Actor::New();
+  actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
+  Stage::GetCurrent().Add(actor);
+
+  DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+
+  KeyFrames keyFrames = KeyFrames::New();
+  keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
+  keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
+  keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
+
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, Animation::Cubic );
 
   // Start the animation
   animation.Play();
@@ -6324,38 +6792,38 @@ int UtcDaliAnimationAnimateBetweenActorColor(void)
   application.Render(0);
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.55f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.506f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.99375f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85625f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
 
   // We did expect the animation to finish
 
@@ -6363,7 +6831,52 @@ int UtcDaliAnimationAnimateBetweenActorColor(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateBetweenActorVisible01(void)
+int UtcDaliAnimationAnimateBetweenActorVisible(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  AngleAxis aa(Degree(90), Vector3::XAXIS);
+  actor.SetRotation(aa.angle, aa.axis);
+  Stage::GetCurrent().Add(actor);
+
+  application.SendNotification();
+  application.Render(0);
+
+  DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION );
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+
+  KeyFrames keyFrames = KeyFrames::New();
+  keyFrames.Add(0.0f, false);
+  keyFrames.Add(0.2f, true);
+  keyFrames.Add(0.4f, true);
+  keyFrames.Add(0.8f, false);
+  keyFrames.Add(1.0f, true);
+
+  animation.AnimateBetween( Property(actor, Actor::Property::VISIBLE), keyFrames );
+
+  // Start the animation
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+  application.SendNotification();
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
+  application.SendNotification();
+
+  DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION);
+  finishCheck.CheckSignalReceived();
+  END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenActorVisibleCubic(void)
 {
   TestApplication application;
 
@@ -6388,7 +6901,8 @@ int UtcDaliAnimationAnimateBetweenActorVisible01(void)
   keyFrames.Add(0.8f, false);
   keyFrames.Add(1.0f, true);
 
-  animation.AnimateBetween( Property(actor, Actor::VISIBLE), keyFrames );
+  //Cubic interpolation for boolean values should be ignored
+  animation.AnimateBetween( Property(actor, Actor::Property::VISIBLE), keyFrames, Animation::Cubic );
 
   // Start the animation
   animation.Play();
@@ -6429,7 +6943,7 @@ int UtcDaliAnimationAnimateBetweenActorRotation01(void)
   KeyFrames keyFrames = KeyFrames::New();
   keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::ZAXIS));
 
-  animation.AnimateBetween( Property(actor, Actor::ROTATION), keyFrames );
+  animation.AnimateBetween( Property(actor, Actor::Property::ROTATION), keyFrames );
 
   // Start the animation
   animation.Play();
@@ -6474,7 +6988,7 @@ int UtcDaliAnimationAnimateBetweenActorRotation02(void)
   keyFrames.Add(0.5f, AngleAxis(Degree(120), Vector3::XAXIS));
   keyFrames.Add(1.0f, AngleAxis(Degree(120), Vector3::YAXIS));
 
-  animation.AnimateBetween( Property(actor, Actor::ROTATION), keyFrames );
+  animation.AnimateBetween( Property(actor, Actor::Property::ROTATION), keyFrames );
 
   // Start the animation
   animation.Play();
@@ -6516,26 +7030,29 @@ int UtcDaliAnimationAnimateBetweenActorRotation02(void)
   END_TEST;
 }
 
-int UtcDaliAnimationMoveByFloat3(void)
+int UtcDaliAnimationAnimateBetweenActorRotation01Cubic(void)
 {
   TestApplication application;
 
   Actor actor = Actor::New();
-  Vector3 startPosition(10.0f, 10.0f, 10.0f);
-  actor.SetPosition(startPosition);
+  AngleAxis aa(Degree(90), Vector3::XAXIS);
+  actor.SetRotation(aa.angle, aa.axis);
   Stage::GetCurrent().Add(actor);
+
   application.SendNotification();
   application.Render(0);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
+  Quaternion start(Radian(aa.angle), aa.axis);
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), start, 0.001f, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
-  Vector3 targetPosition(20.0f, 20.0f, 20.0f);
-  Vector3 relativePosition(targetPosition - startPosition);
-  animation.MoveBy(actor, relativePosition.x, relativePosition.y, relativePosition.z);
 
-  Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
+  KeyFrames keyFrames = KeyFrames::New();
+  keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::ZAXIS));
+
+  //Cubic interpolation should be ignored for quaternions
+  animation.AnimateBetween( Property(actor, Actor::Property::ROTATION), keyFrames, Animation::Cubic );
 
   // Start the animation
   animation.Play();
@@ -6543,45 +7060,45 @@ int UtcDaliAnimationMoveByFloat3(void)
   bool signalReceived(false);
   AnimationFinishCheck finishCheck(signalReceived);
   animation.FinishedSignal().Connect(&application, finishCheck);
-
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
-
-  // We didn't expect the animation to finish yet
   application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), ninetyFivePercentProgress, TEST_LOCATION );
-
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
   application.SendNotification();
+
+  Quaternion check = Quaternion::FromAxisAngle(Vector4::ZAXIS, Radian(Degree(60)));
+
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), check, 0.001f, TEST_LOCATION );
   finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
   END_TEST;
 }
 
-int UtcDaliAnimationMoveByVector3Alpha(void)
+int UtcDaliAnimationAnimateBetweenActorRotation02Cubic(void)
 {
   TestApplication application;
 
   Actor actor = Actor::New();
-  Vector3 startPosition(10.0f, 10.0f, 10.0f);
-  actor.SetPosition(startPosition);
-  Stage::GetCurrent().Add(actor);
+  AngleAxis aa(Degree(90), Vector3::XAXIS);
+  actor.SetRotation(aa.angle, aa.axis);
   application.SendNotification();
   application.Render(0);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
+  Stage::GetCurrent().Add(actor);
+
+  Quaternion start(Radian(aa.angle), aa.axis);
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), start, 0.001f, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
-  Vector3 targetPosition(20.0f, 20.0f, 20.0f);
-  Vector3 relativePosition(targetPosition - startPosition);
-  animation.MoveBy(actor, relativePosition, AlphaFunctions::EaseOut);
 
-  Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
+  KeyFrames keyFrames = KeyFrames::New();
+  keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::XAXIS));
+  keyFrames.Add(0.5f, AngleAxis(Degree(120), Vector3::XAXIS));
+  keyFrames.Add(1.0f, AngleAxis(Degree(120), Vector3::YAXIS));
+
+  //Cubic interpolation should be ignored for quaternions
+  animation.AnimateBetween( Property(actor, Actor::Property::ROTATION), keyFrames, Animation::Cubic );
 
   // Start the animation
   animation.Play();
@@ -6589,31 +7106,42 @@ int UtcDaliAnimationMoveByVector3Alpha(void)
   bool signalReceived(false);
   AnimationFinishCheck finishCheck(signalReceived);
   animation.FinishedSignal().Connect(&application, finishCheck);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
 
+  Quaternion check(Radian(Degree(60)), Vector3::XAXIS);
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), check, 0.001f, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+  check = Quaternion::FromAxisAngle(Vector4::XAXIS, Radian(Degree(90)));
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), check, 0.001f, TEST_LOCATION );
 
-  // We didn't expect the animation to finish yet
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
   application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
+  check = Quaternion::FromAxisAngle(Vector4::XAXIS, Radian(Degree(120)));
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), check, 0.001f, TEST_LOCATION );
 
-  // The position should have moved more, than with a linear alpha function
-  Vector3 current(actor.GetCurrentPosition());
-  DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
-  DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
-  DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  application.SendNotification();
+  check = Quaternion::FromAxisAngle(Vector4(0.5f, 0.5f, 0.0f, 0.0f), Radian(Degree(101.5)));
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), check, 0.001f, TEST_LOCATION );
 
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+  check = Quaternion::FromAxisAngle(Vector4::YAXIS, Radian(Degree(120)));
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), check, 0.001f, TEST_LOCATION );
 
   // We did expect the animation to finish
-  application.SendNotification();
+
   finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
   END_TEST;
 }
 
-int UtcDaliAnimationMoveByVector3AlphaFloat2(void)
+
+int UtcDaliAnimationMoveByFloat3(void)
 {
   TestApplication application;
 
@@ -6630,8 +7158,7 @@ int UtcDaliAnimationMoveByVector3AlphaFloat2(void)
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(20.0f, 20.0f, 20.0f);
   Vector3 relativePosition(targetPosition - startPosition);
-  float delay = 0.5f;
-  animation.MoveBy(actor, relativePosition, AlphaFunctions::Linear, delay, durationSeconds - delay);
+  animation.MoveBy(actor, relativePosition.x, relativePosition.y, relativePosition.z);
 
   Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
 
@@ -6643,15 +7170,15 @@ int UtcDaliAnimationMoveByVector3AlphaFloat2(void)
   animation.FinishedSignal().Connect(&application, finishCheck);
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), ninetyFivePercentProgress, TEST_LOCATION );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+  application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
 
   // We did expect the animation to finish
   application.SendNotification();
@@ -6660,21 +7187,26 @@ int UtcDaliAnimationMoveByVector3AlphaFloat2(void)
   END_TEST;
 }
 
-int UtcDaliAnimationMoveToFloat3(void)
+int UtcDaliAnimationMoveByVector3Alpha(void)
 {
   TestApplication application;
 
   Actor actor = Actor::New();
+  Vector3 startPosition(10.0f, 10.0f, 10.0f);
+  actor.SetPosition(startPosition);
   Stage::GetCurrent().Add(actor);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
-  Vector3 targetPosition(200.0f, 200.0f, 200.0f);
-  animation.MoveTo(actor, targetPosition.x, targetPosition.y, targetPosition.z);
+  Vector3 targetPosition(20.0f, 20.0f, 20.0f);
+  Vector3 relativePosition(targetPosition - startPosition);
+  animation.MoveBy(actor, relativePosition, AlphaFunctions::EaseOut);
 
-  Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
+  Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
 
   // Start the animation
   animation.Play();
@@ -6684,15 +7216,20 @@ int UtcDaliAnimationMoveToFloat3(void)
   animation.FinishedSignal().Connect(&application, finishCheck);
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*750.0f)/* 75% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), seventyFivePercentProgress, TEST_LOCATION );
+
+  // The position should have moved more, than with a linear alpha function
+  Vector3 current(actor.GetCurrentPosition());
+  DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
+  DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
+  DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+  application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
 
   // We did expect the animation to finish
   application.SendNotification();
@@ -6701,21 +7238,27 @@ int UtcDaliAnimationMoveToFloat3(void)
   END_TEST;
 }
 
-int UtcDaliAnimationMoveToVector3Alpha(void)
+int UtcDaliAnimationMoveByVector3AlphaFloat2(void)
 {
   TestApplication application;
 
   Actor actor = Actor::New();
+  Vector3 startPosition(10.0f, 10.0f, 10.0f);
+  actor.SetPosition(startPosition);
   Stage::GetCurrent().Add(actor);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
-  Vector3 targetPosition(200.0f, 200.0f, 200.0f);
-  animation.MoveTo(actor, targetPosition, AlphaFunctions::EaseIn);
+  Vector3 targetPosition(20.0f, 20.0f, 20.0f);
+  Vector3 relativePosition(targetPosition - startPosition);
+  float delay = 0.5f;
+  animation.MoveBy(actor, relativePosition, AlphaFunctions::Linear, delay, durationSeconds - delay);
 
-  Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
+  Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
 
   // Start the animation
   animation.Play();
@@ -6725,23 +7268,15 @@ int UtcDaliAnimationMoveToVector3Alpha(void)
   animation.FinishedSignal().Connect(&application, finishCheck);
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*750.0f)/* 75% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-
-  // The position should have moved less, than with a linear alpha function
-  Vector3 current(actor.GetCurrentPosition());
-  DALI_TEST_CHECK( current.x > Vector3::ZERO.x );
-  DALI_TEST_CHECK( current.y > Vector3::ZERO.y );
-  DALI_TEST_CHECK( current.z > Vector3::ZERO.z );
-  DALI_TEST_CHECK( current.x < seventyFivePercentProgress.x );
-  DALI_TEST_CHECK( current.y < seventyFivePercentProgress.y );
-  DALI_TEST_CHECK( current.z < seventyFivePercentProgress.z );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
 
   // We did expect the animation to finish
   application.SendNotification();
@@ -6750,7 +7285,7 @@ int UtcDaliAnimationMoveToVector3Alpha(void)
   END_TEST;
 }
 
-int UtcDaliAnimationMoveToVector3AlphaFloat2(void)
+int UtcDaliAnimationMoveToFloat3(void)
 {
   TestApplication application;
 
@@ -6762,8 +7297,7 @@ int UtcDaliAnimationMoveToVector3AlphaFloat2(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(200.0f, 200.0f, 200.0f);
-  float delay = 0.5f;
-  animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear, delay, durationSeconds - delay);
+  animation.MoveTo(actor, targetPosition.x, targetPosition.y, targetPosition.z);
 
   Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
 
@@ -6775,15 +7309,7 @@ int UtcDaliAnimationMoveToVector3AlphaFloat2(void)
   animation.FinishedSignal().Connect(&application, finishCheck);
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.75)/* 7/8 animation progress, 3/4 animator progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*750.0f)/* 75% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
@@ -6791,7 +7317,7 @@ int UtcDaliAnimationMoveToVector3AlphaFloat2(void)
   DALI_TEST_EQUALS( actor.GetCurrentPosition(), seventyFivePercentProgress, TEST_LOCATION );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.25) + 1u/*just beyond the animation duration*/);
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
 
   // We did expect the animation to finish
   application.SendNotification();
@@ -6800,21 +7326,21 @@ int UtcDaliAnimationMoveToVector3AlphaFloat2(void)
   END_TEST;
 }
 
-int UtcDaliAnimationMove(void)
+int UtcDaliAnimationMoveToVector3Alpha(void)
 {
   TestApplication application;
 
   Actor actor = Actor::New();
-  Vector3 initialPosition(Vector3::ZERO);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
   Stage::GetCurrent().Add(actor);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
 
   // Build the animation
-  float durationSeconds(10.0f);
+  float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(200.0f, 200.0f, 200.0f);
-  BounceFunc func(0.0f, 0.0f, -100.0f);
-  animation.Move(actor, func, AlphaFunctions::Linear, 0.0f, durationSeconds);
+  animation.MoveTo(actor, targetPosition, AlphaFunctions::EaseIn);
+
+  Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
 
   // Start the animation
   animation.Play();
@@ -6824,36 +7350,78 @@ int UtcDaliAnimationMove(void)
   animation.FinishedSignal().Connect(&application, finishCheck);
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*750.0f)/* 75% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), func(0.25f, initialPosition), TEST_LOCATION );
+
+  // The position should have moved less, than with a linear alpha function
+  Vector3 current(actor.GetCurrentPosition());
+  DALI_TEST_CHECK( current.x > Vector3::ZERO.x );
+  DALI_TEST_CHECK( current.y > Vector3::ZERO.y );
+  DALI_TEST_CHECK( current.z > Vector3::ZERO.z );
+  DALI_TEST_CHECK( current.x < seventyFivePercentProgress.x );
+  DALI_TEST_CHECK( current.y < seventyFivePercentProgress.y );
+  DALI_TEST_CHECK( current.z < seventyFivePercentProgress.z );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+
+  // We did expect the animation to finish
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliAnimationMoveToVector3AlphaFloat2(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  Stage::GetCurrent().Add(actor);
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+  Vector3 targetPosition(200.0f, 200.0f, 200.0f);
+  float delay = 0.5f;
+  animation.MoveTo(actor, targetPosition, AlphaFunctions::Linear, delay, durationSeconds - delay);
+
+  Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
+
+  // Start the animation
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), func(0.5f, initialPosition), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.75)/* 7/8 animation progress, 3/4 animator progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), func(0.75f, initialPosition), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), seventyFivePercentProgress, TEST_LOCATION );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.25) + 1u/*just beyond the animation duration*/);
 
   // We did expect the animation to finish
   application.SendNotification();
   finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
   END_TEST;
 }
 
@@ -7736,63 +8304,6 @@ int UtcDaliAnimationRotateToQuaternionAlphaFloat2(void)
   END_TEST;
 }
 
-int UtcDaliAnimationRotate(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-  Quaternion initialRotation(0.0f, Vector3::YAXIS);
-  actor.SetRotation(initialRotation);
-  Stage::GetCurrent().Add(actor);
-  DALI_TEST_EQUALS( actor.GetCurrentRotation(), initialRotation, ROTATION_EPSILON, TEST_LOCATION );
-
-  // Build the animation
-  float durationSeconds(1.0f);
-  Animation animation = Animation::New(durationSeconds);
-  TumbleFunc func(Vector3::YAXIS);
-  animation.Rotate(actor, func, AlphaFunctions::Linear, 0.0f, durationSeconds);
-
-  // Start the animation
-  animation.Play();
-
-  bool signalReceived(false);
-  AnimationFinishCheck finishCheck(signalReceived);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentRotation(), func(0.25f, initialRotation), ROTATION_EPSILON, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentRotation(), func(0.5f, initialRotation), ROTATION_EPSILON, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentRotation(), func(0.75f, initialRotation), ROTATION_EPSILON, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
-  application.SendNotification();
-  finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentRotation(), func(1.0f, initialRotation), ROTATION_EPSILON, TEST_LOCATION );
-  END_TEST;
-}
-
 int UtcDaliAnimationScaleBy(void)
 {
   TestApplication application;
@@ -8572,449 +9083,51 @@ int UtcDaliAnimationColorTo(void)
   // Repeat with a shorter animator duration
   float animatorDuration = 0.5f;
   animation = Animation::New(durationSeconds);
-  animation.ColorTo(actor, targetColor, AlphaFunctions::Linear, 0, animatorDuration);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-  animation.Play();
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% animation progress, 20% animator progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentColor(), twentyPercentProgress, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 50% animation progress, 100% animator progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
-  application.SendNotification();
-  finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimationResize(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-  Stage::GetCurrent().Add(actor);
-  DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
-
-  // Build the animation
-  float durationSeconds(1.0f);
-  Animation animation = Animation::New(durationSeconds);
-  Vector3 targetSize(100.0f, 100.0f, 100.0f);
-  animation.Resize(actor, targetSize);
-
-  Vector3 ninetyNinePercentProgress(targetSize * 0.99f);
-
-  // Start the animation
-  animation.Play();
-
-  bool signalReceived(false);
-  AnimationFinishCheck finishCheck(signalReceived);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentSize(), ninetyNinePercentProgress, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
-  application.SendNotification();
-  finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
-
-  // Reset everything
-  finishCheck.Reset();
-  actor.SetSize(Vector3::ZERO);
-  application.SendNotification();
-  application.Render(0);
-  DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
-
-  // Repeat with a different (ease-in) alpha function
-  animation = Animation::New(durationSeconds);
-  animation.Resize(actor, targetSize, AlphaFunctions::EaseIn);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-  animation.Play();
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-
-  // The size should have travelled less, than with a linear alpha function
-  Vector3 current(actor.GetCurrentSize());
-  DALI_TEST_CHECK( current.x > 0.0f );
-  DALI_TEST_CHECK( current.y > 0.0f );
-  DALI_TEST_CHECK( current.z > 0.0f );
-  DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
-  DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
-  DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
-  application.SendNotification();
-  finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
-
-  // Reset everything
-  finishCheck.Reset();
-  actor.SetSize(Vector3::ZERO);
-  application.SendNotification();
-  application.Render(0);
-  DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
-
-  // Repeat with a delay
-  float delay = 0.5f;
-  animation = Animation::New(durationSeconds);
-  animation.Resize(actor, targetSize, AlphaFunctions::Linear, delay, durationSeconds - delay);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-  animation.Play();
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
-  application.SendNotification();
-  finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimationAnimateBool(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-  DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION );
-  Stage::GetCurrent().Add(actor);
-
-  // Build the animation
-  float durationSeconds(10.0f);
-  Animation animation = Animation::New(durationSeconds);
-  animation.Animate<bool>( Property(actor, Actor::VISIBLE), ReturnFalseAfterProgressOne, TimePeriod(durationSeconds*0.25f/*delay*/, durationSeconds*0.1f) );
-
-  // Start the animation
-  animation.Play();
-
-  bool signalReceived(false);
-  AnimationFinishCheck finishCheck(signalReceived);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-
-  // Should still be visible
-  DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-
-  // Now animate functor should have hidden the actor
-  DALI_TEST_EQUALS( actor.IsVisible(), false, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
-  application.SendNotification();
-  finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.IsVisible(), false, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimationAnimateFloat(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-  Stage::GetCurrent().Add(actor);
-
-  // Register a float property
-  float startValue(10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
-
-  // Build the animation
-  float durationSeconds(10.0f);
-  Animation animation = Animation::New(durationSeconds);
-  float targetPosition(0.0f);
-  AnimateFloatTestFunctor func( 100, targetPosition );
-  animation.Animate<float>( Property(actor, index), func );
-
-  // Start the animation
-  animation.Play();
-
-  bool signalReceived(false);
-  AnimationFinishCheck finishCheck(signalReceived);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(index), 75.0f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(index), 50.0f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(index), 25.0f, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
-  application.SendNotification();
-  finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(index), targetPosition, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimationAnimateInteger(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-  Stage::GetCurrent().Add(actor);
-
-  // Register an integer property
-  int startValue(10);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
-  DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
-
-  // Build the animation
-  float durationSeconds(10.0f);
-  Animation animation = Animation::New(durationSeconds);
-  int targetPosition(0);
-  AnimateIntegerTestFunctor func( 100, targetPosition );
-  animation.Animate<int>( Property(actor, index), func );
-
-  // Start the animation
-  animation.Play();
-
-  bool signalReceived(false);
-  AnimationFinishCheck finishCheck(signalReceived);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<int>(index), 75, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<int>(index), 50, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<int>(index), 25, TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
-  application.SendNotification();
-  finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<int>(index), targetPosition, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimationAnimateVector2(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-  Stage::GetCurrent().Add(actor);
-
-  // Register a Vector2 property
-  Vector2 startValue(10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
-  DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
-
-  // Build the animation
-  float durationSeconds(10.0f);
-  Animation animation = Animation::New(durationSeconds);
-  Vector2 targetPosition(0.0f, 0.0f);
-  AnimateVector2TestFunctor func( Vector2(100,100), targetPosition );
-  animation.Animate<Vector2>( Property(actor, index), func );
-
-  // Start the animation
-  animation.Play();
-
-  bool signalReceived(false);
-  AnimationFinishCheck finishCheck(signalReceived);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), Vector2(75,75), TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), Vector2(50,50), TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), Vector2(25,25), TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
-  application.SendNotification();
-  finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), targetPosition, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimationAnimateVector3(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-  Vector3 initialPosition(Vector3::ZERO);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
-  Stage::GetCurrent().Add(actor);
-
-  // Build the animation
-  float durationSeconds(10.0f);
-  Animation animation = Animation::New(durationSeconds);
-  Vector3 targetPosition(200.0f, 200.0f, 200.0f);
-  BounceFunc func(0.0f, 0.0f, -100.0f);
-  animation.Animate<Vector3>( Property(actor, Actor::POSITION), func, AlphaFunctions::Linear, durationSeconds );
-
-  // Start the animation
-  animation.Play();
-
-  bool signalReceived(false);
-  AnimationFinishCheck finishCheck(signalReceived);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), func(0.25f, initialPosition), TEST_LOCATION );
+  animation.ColorTo(actor, targetColor, AlphaFunctions::Linear, 0, animatorDuration);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+  animation.Play();
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% animation progress, 20% animator progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), func(0.5f, initialPosition), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentColor(), twentyPercentProgress, TEST_LOCATION );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 50% animation progress, 100% animator progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), func(0.75f, initialPosition), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
 
   // We did expect the animation to finish
   application.SendNotification();
   finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateVector4(void)
+int UtcDaliAnimationResize(void)
 {
   TestApplication application;
 
   Actor actor = Actor::New();
   Stage::GetCurrent().Add(actor);
-
-  // Register a Vector4 property
-  Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
-  DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
 
   // Build the animation
-  float durationSeconds(10.0f);
+  float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
-  Vector4 targetPosition(200,400,0,-1000);
-  AnimateVector4TestFunctor func( Vector4(1000,1000,1000,1000), targetPosition );
-  animation.Animate<Vector4>( Property(actor, index), func );
+  Vector3 targetSize(100.0f, 100.0f, 100.0f);
+  animation.Resize(actor, targetSize);
+
+  Vector3 ninetyNinePercentProgress(targetSize * 0.99f);
 
   // Start the animation
   animation.Play();
@@ -9024,101 +9137,87 @@ int UtcDaliAnimationAnimateVector4(void)
   animation.FinishedSignal().Connect(&application, finishCheck);
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), Vector4(800,850,750,500), TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), Vector4(600,700,500,0), TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), Vector4(400,550,250,-500), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentSize(), ninetyNinePercentProgress, TEST_LOCATION );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+  application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
 
   // We did expect the animation to finish
   application.SendNotification();
   finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), targetPosition, TEST_LOCATION );
-  END_TEST;
-}
-
-int UtcDaliAnimationAnimateQuaternion(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-  actor.SetRotation(Quaternion(0.0f, Vector3::YAXIS));
-  Stage::GetCurrent().Add(actor);
-  DALI_TEST_EQUALS( actor.GetCurrentRotation(), Quaternion(0.0f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
-
-  // Build the animation
-  float durationSeconds(1.0f);
-  Animation animation = Animation::New(durationSeconds);
-
-  Degree sourceRotationDegrees(90.0f);
-  Radian sourceRotationRadians(sourceRotationDegrees);
-  Quaternion sourceRotation(sourceRotationRadians, Vector3::YAXIS);
-
-  Degree targetRotationDegrees(150.0f);
-  Radian targetRotationRadians(targetRotationDegrees);
-  Quaternion targetRotation(targetRotationRadians, Vector3::YAXIS);
-
-  AnimateQuaternionTestFunctor func( sourceRotation, targetRotation );
-  animation.Animate<Quaternion>( Property(actor, Actor::ROTATION), func );
+  DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
 
-  // Start the animation
-  animation.Play();
+  // Reset everything
+  finishCheck.Reset();
+  actor.SetSize(Vector3::ZERO);
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
 
-  bool signalReceived(false);
-  AnimationFinishCheck finishCheck(signalReceived);
+  // Repeat with a different (ease-in) alpha function
+  animation = Animation::New(durationSeconds);
+  animation.Resize(actor, targetSize, AlphaFunctions::EaseIn);
   animation.FinishedSignal().Connect(&application, finishCheck);
+  animation.Play();
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentRotation(), Quaternion(Radian(Degree(105)), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+
+  // The size should have travelled less, than with a linear alpha function
+  Vector3 current(actor.GetCurrentSize());
+  DALI_TEST_CHECK( current.x > 0.0f );
+  DALI_TEST_CHECK( current.y > 0.0f );
+  DALI_TEST_CHECK( current.z > 0.0f );
+  DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
+  DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
+  DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+  application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
 
-  // We didn't expect the animation to finish yet
+  // We did expect the animation to finish
   application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentRotation(), Quaternion(Radian(Degree(120)), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  finishCheck.CheckSignalReceived();
+  DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
 
+  // Reset everything
+  finishCheck.Reset();
+  actor.SetSize(Vector3::ZERO);
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  application.Render(0);
+  DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
+
+  // Repeat with a delay
+  float delay = 0.5f;
+  animation = Animation::New(durationSeconds);
+  animation.Resize(actor, targetSize, AlphaFunctions::Linear, delay, durationSeconds - delay);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+  animation.Play();
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
 
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentRotation(), Quaternion(Radian(Degree(135)), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
 
   application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
 
   // We did expect the animation to finish
   application.SendNotification();
   finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentRotation(), targetRotation, ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
   END_TEST;
 }
 
@@ -9274,10 +9373,10 @@ int UtcDaliAnimationAnimateBetweenActorColorTimePeriod(void)
   Stage::GetCurrent().Add(actor);
 
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
@@ -9288,7 +9387,7 @@ int UtcDaliAnimationAnimateBetweenActorColorTimePeriod(void)
   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
 
-  animation.AnimateBetween( Property(actor, Actor::COLOR), keyFrames, TimePeriod( 1.0f) );
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, TimePeriod( 1.0f) );
 
   // Start the animation
   animation.Play();
@@ -9300,38 +9399,38 @@ int UtcDaliAnimationAnimateBetweenActorColorTimePeriod(void)
   application.Render(0);
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
 
   // We did expect the animation to finish
 
@@ -9349,10 +9448,10 @@ int UtcDaliAnimationAnimateBetweenActorColorFunction(void)
   Stage::GetCurrent().Add(actor);
 
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
@@ -9363,7 +9462,7 @@ int UtcDaliAnimationAnimateBetweenActorColorFunction(void)
   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
 
-  animation.AnimateBetween( Property(actor, Actor::COLOR), keyFrames, AlphaFunctions::Linear );
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunctions::Linear );
 
   // Start the animation
   animation.Play();
@@ -9375,38 +9474,38 @@ int UtcDaliAnimationAnimateBetweenActorColorFunction(void)
   application.Render(0);
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
 
   // We did expect the animation to finish
 
@@ -9424,10 +9523,10 @@ int UtcDaliAnimationAnimateBetweenActorColorFunctionTimePeriod(void)
   Stage::GetCurrent().Add(actor);
 
   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  startValue, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
 
   // Build the animation
   float durationSeconds(1.0f);
@@ -9438,7 +9537,7 @@ int UtcDaliAnimationAnimateBetweenActorColorFunctionTimePeriod(void)
   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
 
-  animation.AnimateBetween( Property(actor, Actor::COLOR), keyFrames, AlphaFunctions::Linear, TimePeriod( 1.0f) );
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunctions::Linear, TimePeriod( 1.0f) );
 
   // Start the animation
   animation.Play();
@@ -9450,38 +9549,38 @@ int UtcDaliAnimationAnimateBetweenActorColorFunctionTimePeriod(void)
   application.Render(0);
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
 
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
   application.SendNotification();
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
 
   // We did expect the animation to finish
 
@@ -9489,63 +9588,6 @@ int UtcDaliAnimationAnimateBetweenActorColorFunctionTimePeriod(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateVector3Func(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-  Vector3 initialPosition(Vector3::ZERO);
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
-  Stage::GetCurrent().Add(actor);
-
-  // Build the animation
-  float durationSeconds(10.0f);
-  Animation animation = Animation::New(durationSeconds);
-  Vector3 targetPosition(200.0f, 200.0f, 200.0f);
-  BounceFunc func(0.0f, 0.0f, -100.0f);
-  animation.Animate<Vector3>( Property(actor, Actor::POSITION), func, AlphaFunctions::Linear );
-
-  // Start the animation
-  animation.Play();
-
-  bool signalReceived(false);
-  AnimationFinishCheck finishCheck(signalReceived);
-  animation.FinishedSignal().Connect(&application, finishCheck);
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), func(0.25f, initialPosition), TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), func(0.5f, initialPosition), TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
-
-  // We didn't expect the animation to finish yet
-  application.SendNotification();
-  finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), func(0.75f, initialPosition), TEST_LOCATION );
-
-  application.SendNotification();
-  application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
-
-  // We did expect the animation to finish
-  application.SendNotification();
-  finishCheck.CheckSignalReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
-  END_TEST;
-}
-
 int UtcDaliAnimationCreateDestroy(void)
 {
   TestApplication application;
@@ -9591,8 +9633,7 @@ int UtcDaliAnimationUpdateManager(void)
   actor.ApplyConstraint( constraint );
 
   // Apply animation to actor
-  BounceFunc func(0.0f, 0.0f, -100.0f);
-  animation.Animate<Vector3>( Property(actor, Actor::POSITION), func, AlphaFunctions::Linear );
+  animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 100.f, 90.f, 80.f ), AlphaFunctions::Linear );
 
   animation.Play();
 
@@ -9626,9 +9667,9 @@ int UtcDaliAnimationSignalOrder(void)
   animation2.FinishedSignal().Connect( &application, AnimationFinishCheck( signal2Received ) );
 
   // Apply animations to actor
-  animation1.AnimateTo( Property(actor, Actor::POSITION), Vector3( 3.0f, 2.0f, 1.0f ), AlphaFunctions::Linear );
+  animation1.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 3.0f, 2.0f, 1.0f ), AlphaFunctions::Linear );
   animation1.Play();
-  animation2.AnimateTo( Property(actor, Actor::SIZE ), Vector3( 10.0f, 20.0f, 30.0f ), AlphaFunctions::Linear );
+  animation2.AnimateTo( Property(actor, Actor::Property::SIZE ), Vector3( 10.0f, 20.0f, 30.0f ), AlphaFunctions::Linear );
   animation2.Play();
 
   DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
@@ -9660,3 +9701,143 @@ int UtcDaliAnimationSignalOrder(void)
 
   END_TEST;
 }
+
+int UtcDaliAnimationExtendDuration(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+
+  // Register a float property
+  float startValue(10.0f);
+  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Stage::GetCurrent().Add(actor);
+  DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
+
+  // Build the animation
+  float initialDurationSeconds(1.0f);
+  float animatorDelay = 5.0f;
+  float animatorDurationSeconds(5.0f);
+  float extendedDurationSeconds(animatorDelay+animatorDurationSeconds);
+  Animation animation = Animation::New(initialDurationSeconds);
+  float targetValue(30.0f);
+  float relativeValue(targetValue - startValue);
+
+  animation.AnimateTo(Property(actor, index),
+                      targetValue,
+                      TimePeriod(animatorDelay, animatorDurationSeconds));
+
+  // The duration should have been extended
+  DALI_TEST_EQUALS( animation.GetDuration(), extendedDurationSeconds, TEST_LOCATION );
+
+  // Start the animation
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(extendedDurationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(extendedDurationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue+(relativeValue*0.5f), TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(extendedDurationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+
+  // We did expect the animation to finish
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+  DALI_TEST_EQUALS( actor.GetProperty<float>(index), targetValue, TEST_LOCATION );
+  END_TEST;
+}
+
+int UtcDaliAnimationPath(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  Stage::GetCurrent().Add(actor);
+
+  //Build the path
+  Vector3 position0( 30.0,  80.0,  0.0);
+  Vector3 position1( 70.0,  120.0, 0.0);
+  Vector3 position2( 100.0, 100.0, 0.0);
+
+  Dali::Path path = Dali::Path::New();
+  path.AddPoint(position0);
+  path.AddPoint(position1);
+  path.AddPoint(position2);
+
+  //Control points for first segment
+  path.AddControlPoint( Vector3( 39.0,  90.0, 0.0) );
+  path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
+
+  //Control points for second segment
+  path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
+  path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
+
+  // Build the animation
+  float durationSeconds( 1.0f );
+  Animation animation = Animation::New(durationSeconds);
+  animation.Animate(actor, path, Vector3::XAXIS, AlphaFunctions::Linear, TimePeriod(0.0f, 1.0f ));
+
+  // Start the animation
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  Vector3 position, tangent;
+  Quaternion rotation;
+  path.Sample( 0.0f, position, tangent );
+  rotation = Quaternion( Vector3::XAXIS, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), rotation, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+  application.SendNotification();
+  path.Sample( 0.25f, position, tangent );
+  rotation = Quaternion( Vector3::XAXIS, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), rotation, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+  application.SendNotification();
+  path.Sample( 0.5f, position, tangent );
+  rotation = Quaternion( Vector3::XAXIS, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), rotation, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+  application.SendNotification();
+  path.Sample( 0.75f, position, tangent );
+  rotation = Quaternion( Vector3::XAXIS, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), rotation, TEST_LOCATION );
+
+  application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+  application.SendNotification();
+  path.Sample( 1.0f, position, tangent );
+  rotation = Quaternion( Vector3::XAXIS, tangent );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentRotation(), rotation, TEST_LOCATION );
+
+  finishCheck.CheckSignalReceived();
+  END_TEST;
+}