Merge "Update Events' public header comments" into devel/master

[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 698e12c..5a288f4 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-Animation.cpp
+++ b/automated-tests/src/dali/utc-Dali-Animation.cpp
@@ -183,7 +183,7 @@ int UtcDaliAnimationAssignmentOperatorP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationSetDuratioN(void)
+int UtcDaliAnimationSetDurationP(void)
 {
   TestApplication application;
 
@@ -197,7 +197,7 @@ int UtcDaliAnimationSetDuratioN(void)
 
   // Start the animation
   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
   animation.Play();
 
   bool signalReceived(false);
@@ -260,7 +260,7 @@ int UtcDaliAnimationSetDurationN(void)
   END_TEST;
 }
 
-int UtcDaliAnimationGetDuratioN(void)
+int UtcDaliAnimationGetDurationP(void)
 {
   TestApplication application;
 
@@ -283,7 +283,7 @@ int UtcDaliAnimationSetLoopingP(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   // Start the animation
   animation.SetLooping(true);
@@ -336,6 +336,422 @@ int UtcDaliAnimationSetLoopingP(void)
   END_TEST;
 }
 
+int UtcDaliAnimationSetLoopCountP(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(10.0f, 10.0f, 10.0f);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+  // Start the animation
+  animation.SetLoopCount(3);
+  DALI_TEST_CHECK(animation.IsLooping());
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  application.Render(0);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+
+  // Loop
+  float intervalSeconds = 3.0f;
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+
+  application.Render(0);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+  DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
+
+  finishCheck.Reset();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  END_TEST;
+}
+
+int UtcDaliAnimationSetLoopCountP2(void)
+{
+  TestApplication application;
+
+  //
+  // switching between forever and loop count
+  //
+
+  Actor actor = Actor::New();
+  Stage::GetCurrent().Add(actor);
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+  Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+  animation.SetEndAction(Animation::Discard);
+
+  // Start the animation
+  animation.SetLoopCount(3);
+  DALI_TEST_CHECK(animation.IsLooping());
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  float intervalSeconds = 3.0f;
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+
+  finishCheck.Reset();
+
+  // Loop forever
+  animation.SetLooping(true);
+  DALI_TEST_CHECK(animation.IsLooping());
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  finishCheck.Reset();
+
+  // Loop N again
+  animation.SetLoopCount(3);
+  DALI_TEST_CHECK(animation.IsLooping());
+  animation.Play();
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+
+  finishCheck.Reset();
+
+  // loop forever
+  animation.SetLooping(true);
+  DALI_TEST_CHECK(animation.IsLooping());
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  finishCheck.Reset();
+
+  // Loop N again
+  animation.SetLoopCount(3);
+  DALI_TEST_CHECK(animation.IsLooping());
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived(); // we never hit play
+
+  finishCheck.Reset();
+
+
+  END_TEST;
+}
+
+int UtcDaliAnimationSetLoopCountP3(void)
+{
+  TestApplication application;
+
+  //
+  // switching between forever and loop count
+  //
+  Actor actor = Actor::New();
+  Stage::GetCurrent().Add(actor);
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+  Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+  animation.SetEndAction(Animation::Discard);
+
+  float intervalSeconds = 3.0f;
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  // loop forever
+  animation.SetLooping(true);
+  DALI_TEST_CHECK(animation.IsLooping());
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  finishCheck.Reset();
+
+  // Loop N again
+  animation.SetLoopCount(3);
+  DALI_TEST_CHECK(animation.IsLooping());
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived(); // we never hit play
+
+  finishCheck.Reset();
+
+
+  END_TEST;
+}
+
+int UtcDaliAnimationSetLoopCountP4(void)
+{
+  TestApplication application;
+
+  //
+  // ..and play again
+  //
+  Actor actor = Actor::New();
+  Stage::GetCurrent().Add(actor);
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+  Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+  animation.SetEndAction(Animation::Bake);
+
+  float intervalSeconds = 3.0f;
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  animation.SetLoopCount(1);
+  animation.Play();
+  DALI_TEST_CHECK(!animation.IsLooping());
+
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
+  actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f) );
+
+  finishCheck.Reset();
+
+  animation.Play(); // again
+  DALI_TEST_CHECK(!animation.IsLooping());
+
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAnimationGetLoopCountP(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(10.0f, 10.0f, 10.0f);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+  DALI_TEST_CHECK(1 == animation.GetLoopCount());
+
+  // Start the animation
+  animation.SetLoopCount(3);
+  DALI_TEST_CHECK(animation.IsLooping());
+  DALI_TEST_CHECK(3 == animation.GetLoopCount());
+
+  animation.Play();
+
+  application.Render(0);
+  application.SendNotification();
+
+  // Loop
+  float intervalSeconds = 3.0f;
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+
+  application.Render(0);
+  application.SendNotification();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+
+  animation.SetLoopCount(0);
+  DALI_TEST_CHECK(animation.IsLooping());
+  DALI_TEST_CHECK(0 == animation.GetLoopCount());
+
+  animation.SetLoopCount(1);
+  DALI_TEST_CHECK(!animation.IsLooping());
+  DALI_TEST_CHECK(1 == animation.GetLoopCount());
+
+  END_TEST;
+}
+
+
+int UtcDaliAnimationGetCurrentLoopP(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(10.0f, 10.0f, 10.0f);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+  // Start the animation
+  animation.SetLoopCount(3);
+  DALI_TEST_CHECK(animation.IsLooping());
+  DALI_TEST_CHECK(0 == animation.GetCurrentLoop());
+  animation.Play();
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  application.SendNotification();
+
+  // Loop
+  float intervalSeconds = 3.0f;
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_CHECK(2 == animation.GetCurrentLoop());
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+
+  application.SendNotification();
+  finishCheck.CheckSignalReceived();
+  DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
+  DALI_TEST_CHECK(animation.GetLoopCount() == animation.GetCurrentLoop());
+
+  finishCheck.Reset();
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
+
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
+
+  END_TEST;
+}
+
 int UtcDaliAnimationIsLoopingP(void)
 {
   TestApplication application;
@@ -361,7 +777,7 @@ int UtcDaliAnimationSetEndActioN(void)
   DALI_TEST_CHECK(animation.GetEndAction() == Animation::Bake);
 
   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   // Start the animation
   animation.Play();
@@ -437,7 +853,7 @@ int UtcDaliAnimationSetEndActioN(void)
   END_TEST;
 }
 
-int UtcDaliAnimationGetEndActioN(void)
+int UtcDaliAnimationGetEndActionP(void)
 {
   TestApplication application;
 
@@ -453,7 +869,7 @@ int UtcDaliAnimationGetEndActioN(void)
   END_TEST;
 }
 
-int UtcDaliAnimationSetDisconnectActioN(void)
+int UtcDaliAnimationSetDisconnectActionP(void)
 {
   TestApplication application;
   Stage stage( Stage::GetCurrent() );
@@ -469,7 +885,7 @@ int UtcDaliAnimationSetDisconnectActioN(void)
     DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::BakeFinal);
 
     Vector3 targetPosition(10.0f, 10.0f, 10.0f);
-    animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+    animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
     // Start the animation
     animation.Play();
@@ -496,7 +912,7 @@ int UtcDaliAnimationSetDisconnectActioN(void)
     animation.SetDisconnectAction( Animation::Bake );
 
     Vector3 targetPosition(10.0f, 10.0f, 10.0f);
-    animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+    animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
     // Start the animation
     animation.Play();
@@ -523,7 +939,7 @@ int UtcDaliAnimationSetDisconnectActioN(void)
     animation.SetDisconnectAction( Animation::Discard );
 
     Vector3 targetPosition(10.0f, 10.0f, 10.0f);
-    animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+    animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
     // Start the animation
     animation.Play();
@@ -549,7 +965,7 @@ int UtcDaliAnimationSetDisconnectActioN(void)
     Animation animation = Animation::New(durationSeconds);
 
     Vector3 targetPosition(10.0f, 10.0f, 10.0f);
-    animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+    animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
     application.SendNotification();
     application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
@@ -565,7 +981,7 @@ int UtcDaliAnimationSetDisconnectActioN(void)
   END_TEST;
 }
 
-int UtcDaliAnimationGetDisconnectActioN(void)
+int UtcDaliAnimationGetDisconnectActionP(void)
 {
   TestApplication application;
   Animation animation = Animation::New(1.0f);
@@ -580,21 +996,21 @@ int UtcDaliAnimationGetDisconnectActioN(void)
   END_TEST;
 }
 
-int UtcDaliAnimationSetDefaultAlphaFunctioN(void)
+int UtcDaliAnimationSetDefaultAlphaFunctionP(void)
 {
   TestApplication application;
 
   Animation animation = Animation::New(1.0f);
   AlphaFunction func = animation.GetDefaultAlphaFunction();
-  DALI_TEST_EQUALS(func(0.1f), AlphaFunctions::Linear(0.1f), TEST_LOCATION);
+  DALI_TEST_EQUALS(func.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
 
-  animation.SetDefaultAlphaFunction(AlphaFunctions::EaseIn);
+  animation.SetDefaultAlphaFunction(AlphaFunction::EASE_IN);
   AlphaFunction func2 = animation.GetDefaultAlphaFunction();
-  DALI_TEST_CHECK(func2(0.1f) < AlphaFunctions::Linear(0.1f)); // less progress when easing-in
+  DALI_TEST_EQUALS(func2.GetBuiltinFunction(), AlphaFunction::EASE_IN, TEST_LOCATION);
   END_TEST;
 }
 
-int UtcDaliAnimationGetDefaultAlphaFunctioN(void)
+int UtcDaliAnimationGetDefaultAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -602,11 +1018,11 @@ int UtcDaliAnimationGetDefaultAlphaFunctioN(void)
   AlphaFunction func = animation.GetDefaultAlphaFunction();
 
   // Test that the default is linear
-  DALI_TEST_EQUALS(func(0.1f), AlphaFunctions::Linear(0.1f), TEST_LOCATION);
+  DALI_TEST_EQUALS(func.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
 
-  animation.SetDefaultAlphaFunction(AlphaFunctions::EaseIn);
+  animation.SetDefaultAlphaFunction(AlphaFunction::EASE_IN);
   AlphaFunction func2 = animation.GetDefaultAlphaFunction();
-  DALI_TEST_CHECK(func2(0.1f) < AlphaFunctions::Linear(0.1f)); // less progress when easing-in
+  DALI_TEST_EQUALS(func2.GetBuiltinFunction(), AlphaFunction::EASE_IN, TEST_LOCATION);
 
   END_TEST;
 }
@@ -631,7 +1047,7 @@ int UtcDaliAnimationSetCurrentProgressP(void)
   application.SendNotification();
 
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   // Start the animation from 40% progress
   animation.SetCurrentProgress( 0.4f );
@@ -694,7 +1110,7 @@ int UtcDaliAnimationSetCurrentProgressN(void)
   application.SendNotification();
 
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   //Trying to set the current cursor outside the range [0..1] is ignored
   animation.SetCurrentProgress( -1.0f);
@@ -739,7 +1155,7 @@ int UtcDaliAnimationGetCurrentProgressP(void)
   application.SendNotification();
 
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   // Start the animation from 40% progress
   animation.SetCurrentProgress( 0.4f );
@@ -790,7 +1206,7 @@ int UtcDaliAnimationSetSpeedFactorP(void)
   KeyFrames keyframes = KeyFrames::New();
   keyframes.Add( 0.0f, initialPosition);
   keyframes.Add( 1.0f, targetPosition );
-  animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunctions::Linear);
+  animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
 
   //Set speed to be x2
   animation.SetSpeedFactor(2.0f);
@@ -971,7 +1387,7 @@ int UtcDaliAnimationSetPlayRangeP(void)
   DALI_TEST_EQUALS( Vector2( 0.4f, 0.9f ), animation.GetPlayRange(), TEST_LOCATION );
 
   Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
-  animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunctions::Linear );
+  animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR );
 
   // Start the animation from 40% progress
   animation.Play();
@@ -1061,7 +1477,7 @@ int UtcDaliAnimationPlayP(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   // Start the animation
   animation.Play();
@@ -1140,7 +1556,7 @@ int UtcDaliAnimationPlayOffStageP(void)
   Animation animation = Animation::New(durationSeconds);
   animation.SetDisconnectAction( Animation::Discard );
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   // Start the animation
   animation.Play();
@@ -1219,7 +1635,7 @@ int UtcDaliAnimationPlayDiscardHandleP(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   bool signalReceived(false);
   AnimationFinishCheck finishCheck(signalReceived);
@@ -1292,7 +1708,7 @@ int UtcDaliAnimationPlayStopDiscardHandleP(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   // Start the animation
   animation.Play();
@@ -1465,7 +1881,7 @@ int UtcDaliAnimationPlayFromP(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   // Start the animation from 40% progress
   animation.PlayFrom( 0.4f );
@@ -1516,7 +1932,7 @@ int UtcDaliAnimationPlayFromN(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   //PlayFrom with an argument outside the range [0..1] will be ignored
   animation.PlayFrom(-1.0f);
@@ -1540,7 +1956,7 @@ int UtcDaliAnimationPauseP(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   Vector3 fiftyPercentProgress(targetPosition * 0.5f);
 
@@ -1599,7 +2015,101 @@ int UtcDaliAnimationPauseP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationStoP(void)
+
+int UtcDaliAnimationGetStateP(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.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+  DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
+
+  Vector3 fiftyPercentProgress(targetPosition * 0.5f);
+
+  // Start the animation
+  animation.Play();
+
+  DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
+
+  bool signalReceived(false);
+  AnimationFinishCheck finishCheck(signalReceived);
+  animation.FinishedSignal().Connect(&application, finishCheck);
+
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
+
+  // Pause the animation
+  animation.Pause();
+  DALI_TEST_EQUALS( animation.GetState(), Animation::PAUSED, TEST_LOCATION );
+  application.SendNotification();
+  application.Render(0.f);
+
+  // Loop 5 times
+  for (int i=0; i<5; ++i)
+  {
+    application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
+
+    // We didn't expect the animation to finish yet
+    application.SendNotification();
+    finishCheck.CheckSignalNotReceived();
+    DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress/* Still 50% progress when paused */, TEST_LOCATION );
+    DALI_TEST_EQUALS( animation.GetState(), Animation::PAUSED, TEST_LOCATION );
+  }
+
+  // Keep going
+  finishCheck.Reset();
+  animation.Play();
+  DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, 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.GetCurrentPosition(), targetPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, 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 );
+  DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
+
+  // re-play
+  finishCheck.Reset();
+  animation.Play();
+  DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
+  application.SendNotification();
+  application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
+
+
+  END_TEST;
+}
+
+int UtcDaliAnimationStopP(void)
 {
   TestApplication application;
 
@@ -1610,7 +2120,7 @@ int UtcDaliAnimationStoP(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   Vector3 fiftyPercentProgress(targetPosition * 0.5f);
 
@@ -1646,7 +2156,7 @@ int UtcDaliAnimationStoP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationStopSetPositioN(void)
+int UtcDaliAnimationStopSetPositionP(void)
 {
   // Test that Animation::Stop & Actor::SetPosition can be used in conjunction
   // i.e. to check that the animation does not interfere with the position set.
@@ -1660,7 +2170,7 @@ int UtcDaliAnimationStopSetPositioN(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   Vector3 fiftyPercentProgress(targetPosition * 0.5f);
 
@@ -1709,7 +2219,7 @@ int UtcDaliAnimationClearP(void)
   float durationSeconds(1.0f);
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
-  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 
   Vector3 fiftyPercentProgress(targetPosition * 0.5f);
 
@@ -1743,7 +2253,7 @@ int UtcDaliAnimationClearP(void)
   finishCheck.Reset();
   actor.SetPosition(Vector3::ZERO);
   Vector3 targetScale(3.0f, 3.0f, 3.0f);
-  animation.AnimateTo( Property( actor, Actor::Property::SCALE ), targetScale, AlphaFunctions::Linear );
+  animation.AnimateTo( Property( actor, Actor::Property::SCALE ), targetScale, AlphaFunction::LINEAR );
   animation.Play();
 
   application.SendNotification();
@@ -1787,7 +2297,7 @@ int UtcDaliAnimationFinishedSignalP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByBooleaN(void)
+int UtcDaliAnimationAnimateByBooleanP(void)
 {
   TestApplication application;
 
@@ -1795,7 +2305,7 @@ int UtcDaliAnimationAnimateByBooleaN(void)
 
   // Register a boolean property
   bool startValue(false);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
 
@@ -1870,7 +2380,7 @@ int UtcDaliAnimationAnimateByBooleaN(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByBooleanAlphaFunctioN(void)
+int UtcDaliAnimationAnimateByBooleanAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -1878,7 +2388,7 @@ int UtcDaliAnimationAnimateByBooleanAlphaFunctioN(void)
 
   // Register a boolean property
   bool startValue(false);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
 
@@ -1887,7 +2397,7 @@ int UtcDaliAnimationAnimateByBooleanAlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   bool relativeValue(true);
   bool finalValue( false || relativeValue );
-  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseIn);
+  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_IN);
 
   // Start the animation
   animation.Play();
@@ -1921,7 +2431,7 @@ int UtcDaliAnimationAnimateByBooleanAlphaFunctioN(void)
   // Repeat with relative value "false" - this should be an NOOP
   animation = Animation::New(durationSeconds);
   bool noOpValue(false);
-  animation.AnimateBy(Property(actor, index), noOpValue, AlphaFunctions::EaseIn);
+  animation.AnimateBy(Property(actor, index), noOpValue, AlphaFunction::EASE_IN);
 
   // Start the animation
   animation.Play();
@@ -1955,7 +2465,7 @@ int UtcDaliAnimationAnimateByBooleanTimePeriodP(void)
 
   // Register a boolean property
   bool startValue(false);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
 
@@ -2018,7 +2528,7 @@ int UtcDaliAnimationAnimateByBooleanAlphaFunctionTimePeriodP(void)
 
   // Register a boolean property
   bool startValue(false);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
 
@@ -2030,7 +2540,7 @@ int UtcDaliAnimationAnimateByBooleanAlphaFunctionTimePeriodP(void)
   float animatorDurationSeconds(durationSeconds * 0.5f);
   animation.AnimateBy( Property(actor, index),
                        relativeValue,
-                       AlphaFunctions::EaseInOut,
+                       AlphaFunction::EASE_IN_OUT,
                        TimePeriod( animatorDurationSeconds ) );
 
   // Start the animation
@@ -2082,7 +2592,7 @@ int UtcDaliAnimationAnimateByFloatP(void)
 
   // Register a float property
   float startValue(10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
 
@@ -2126,7 +2636,7 @@ int UtcDaliAnimationAnimateByFloatP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByFloatAlphaFunctioN(void)
+int UtcDaliAnimationAnimateByFloatAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -2134,7 +2644,7 @@ int UtcDaliAnimationAnimateByFloatAlphaFunctioN(void)
 
   // Register a float property
   float startValue(10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
 
@@ -2143,7 +2653,7 @@ int UtcDaliAnimationAnimateByFloatAlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   float targetValue(90.0f);
   float relativeValue(targetValue - startValue);
-  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseOut);
+  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
 
   float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
 
@@ -2189,7 +2699,7 @@ int UtcDaliAnimationAnimateByFloatTimePeriodP(void)
 
   // Register a float property
   float startValue(10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
 
@@ -2250,7 +2760,7 @@ int UtcDaliAnimationAnimateByFloatAlphaFunctionTimePeriodP(void)
 
   // Register a float property
   float startValue(10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
 
@@ -2262,7 +2772,7 @@ int UtcDaliAnimationAnimateByFloatAlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateBy(Property(actor, index),
                       relativeValue,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -2312,7 +2822,7 @@ int UtcDaliAnimationAnimateByIntegerP(void)
 
   // Register an integer property
   int startValue(1);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
 
@@ -2356,7 +2866,7 @@ int UtcDaliAnimationAnimateByIntegerP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByIntegerAlphaFunctioN(void)
+int UtcDaliAnimationAnimateByIntegerAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -2364,7 +2874,7 @@ int UtcDaliAnimationAnimateByIntegerAlphaFunctioN(void)
 
   // Register an integer property
   int startValue(1);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
 
@@ -2373,7 +2883,7 @@ int UtcDaliAnimationAnimateByIntegerAlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   int targetValue(90);
   int relativeValue(targetValue - startValue);
-  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseOut);
+  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
 
   int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
 
@@ -2419,7 +2929,7 @@ int UtcDaliAnimationAnimateByIntegerTimePeriodP(void)
 
   // Register an integer property
   int startValue(10);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
 
@@ -2480,7 +2990,7 @@ int UtcDaliAnimationAnimateByIntegerAlphaFunctionTimePeriodP(void)
 
   // Register an integer property
   int startValue(10);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
 
@@ -2492,7 +3002,7 @@ int UtcDaliAnimationAnimateByIntegerAlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateBy(Property(actor, index),
                       relativeValue,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -2542,7 +3052,7 @@ int UtcDaliAnimationAnimateByVector2P(void)
 
   // Register a Vector2 property
   Vector2 startValue(10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
 
@@ -2586,7 +3096,7 @@ int UtcDaliAnimationAnimateByVector2P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByVector2AlphaFunctioN(void)
+int UtcDaliAnimationAnimateByVector2AlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -2594,7 +3104,7 @@ int UtcDaliAnimationAnimateByVector2AlphaFunctioN(void)
 
   // Register a Vector2 property
   Vector2 startValue(100.0f, 100.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
 
@@ -2603,7 +3113,7 @@ int UtcDaliAnimationAnimateByVector2AlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   Vector2 targetValue(20.0f, 20.0f);
   Vector2 relativeValue(targetValue - startValue);
-  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseOut);
+  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
 
   Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
 
@@ -2650,7 +3160,7 @@ int UtcDaliAnimationAnimateByVector2TimePeriodP(void)
 
   // Register a Vector2 property
   Vector2 startValue(10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
 
@@ -2711,7 +3221,7 @@ int UtcDaliAnimationAnimateByVector2AlphaFunctionTimePeriodP(void)
 
   // Register a Vector2 property
   Vector2 startValue(5.0f, 5.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
 
@@ -2723,7 +3233,7 @@ int UtcDaliAnimationAnimateByVector2AlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateBy(Property(actor, index),
                       relativeValue,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -2773,7 +3283,7 @@ int UtcDaliAnimationAnimateByVector3P(void)
 
   // Register a Vector3 property
   Vector3 startValue(10.0f, 10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
 
@@ -2817,7 +3327,7 @@ int UtcDaliAnimationAnimateByVector3P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByVector3AlphaFunctioN(void)
+int UtcDaliAnimationAnimateByVector3AlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -2825,7 +3335,7 @@ int UtcDaliAnimationAnimateByVector3AlphaFunctioN(void)
 
   // Register a Vector3 property
   Vector3 startValue(100.0f, 100.0f, 100.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
 
@@ -2834,7 +3344,7 @@ int UtcDaliAnimationAnimateByVector3AlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetValue(20.0f, 20.0f, 20.0f);
   Vector3 relativeValue(targetValue - startValue);
-  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseOut);
+  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
 
   Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
 
@@ -2882,7 +3392,7 @@ int UtcDaliAnimationAnimateByVector3TimePeriodP(void)
 
   // Register a Vector3 property
   Vector3 startValue(10.0f, 10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
 
@@ -2943,7 +3453,7 @@ int UtcDaliAnimationAnimateByVector3AlphaFunctionTimePeriodP(void)
 
   // Register a Vector3 property
   Vector3 startValue(5.0f, 5.0f, 5.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
 
@@ -2955,7 +3465,7 @@ int UtcDaliAnimationAnimateByVector3AlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateBy(Property(actor, index),
                       relativeValue,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -3005,7 +3515,7 @@ int UtcDaliAnimationAnimateByVector4P(void)
 
   // Register a Vector4 property
   Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
 
@@ -3049,7 +3559,7 @@ int UtcDaliAnimationAnimateByVector4P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByVector4AlphaFunctioN(void)
+int UtcDaliAnimationAnimateByVector4AlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -3057,7 +3567,7 @@ int UtcDaliAnimationAnimateByVector4AlphaFunctioN(void)
 
   // Register a Vector4 property
   Vector4 startValue(100.0f, 100.0f, 100.0f, 100.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
 
@@ -3066,7 +3576,7 @@ int UtcDaliAnimationAnimateByVector4AlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   Vector4 targetValue(20.0f, 20.0f, 20.0f, 20.0f);
   Vector4 relativeValue(targetValue - startValue);
-  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseOut);
+  animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
 
   Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
 
@@ -3115,7 +3625,7 @@ int UtcDaliAnimationAnimateByVector4TimePeriodP(void)
 
   // Register a Vector4 property
   Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
 
@@ -3176,7 +3686,7 @@ int UtcDaliAnimationAnimateByVector4AlphaFunctionTimePeriodP(void)
 
   // Register a Vector4 property
   Vector4 startValue(5.0f, 5.0f, 5.0f, 5.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
 
@@ -3188,7 +3698,7 @@ int UtcDaliAnimationAnimateByVector4AlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateBy(Property(actor, index),
                       relativeValue,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -3230,7 +3740,7 @@ int UtcDaliAnimationAnimateByVector4AlphaFunctionTimePeriodP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByActorPositioN(void)
+int UtcDaliAnimationAnimateByActorPositionP(void)
 {
   TestApplication application;
 
@@ -3282,7 +3792,7 @@ int UtcDaliAnimationAnimateByActorPositioN(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByActorPositionAlphaFunctioN(void)
+int UtcDaliAnimationAnimateByActorPositionAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -3299,7 +3809,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::Property::POSITION), relativePosition, AlphaFunctions::EaseOut);
+  animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition, AlphaFunction::EASE_OUT);
 
   Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
 
@@ -3414,7 +3924,7 @@ int UtcDaliAnimationAnimateByActorPositionAlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateBy(Property(actor, Actor::Property::POSITION),
                       relativePosition,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
@@ -3450,7 +3960,7 @@ int UtcDaliAnimationAnimateByActorPositionAlphaFunctionTimePeriodP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByActorOrientatioN(void)
+int UtcDaliAnimationAnimateByActorOrientationP(void)
 {
   TestApplication application;
 
@@ -3507,7 +4017,7 @@ int UtcDaliAnimationAnimateByActorOrientatioN(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateByActorOrientationAlphaFunctioN(void)
+int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -3521,7 +4031,7 @@ int UtcDaliAnimationAnimateByActorOrientationAlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   Degree relativeRotationDegrees(360.0f);
   Radian relativeRotationRadians(relativeRotationDegrees);
-  animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ), AlphaFunctions::EaseIn );
+  animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ), AlphaFunction::EASE_IN );
 
   // Start the animation
   animation.Play();
@@ -3536,7 +4046,7 @@ int UtcDaliAnimationAnimateByActorOrientationAlphaFunctioN(void)
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(0.25f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.25f*0.25f*0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
@@ -3544,7 +4054,7 @@ int UtcDaliAnimationAnimateByActorOrientationAlphaFunctioN(void)
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(0.5f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.5f*0.5f*0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
@@ -3552,7 +4062,7 @@ int UtcDaliAnimationAnimateByActorOrientationAlphaFunctioN(void)
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(0.75f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.75f*0.75f*0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
@@ -3580,7 +4090,7 @@ int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionTimePeriodP(void)
   Radian relativeRotationRadians(relativeRotationDegrees);
   float delay = 0.3f;
   animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ),
-                       AlphaFunctions::EaseIn, TimePeriod( delay, durationSeconds - delay ) );
+                       AlphaFunction::EASE_IN, TimePeriod( delay, durationSeconds - delay ) );
 
   // Start the animation
   animation.Play();
@@ -3596,7 +4106,7 @@ int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionTimePeriodP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
@@ -3605,7 +4115,7 @@ int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionTimePeriodP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
@@ -3614,7 +4124,7 @@ int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionTimePeriodP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
@@ -3675,7 +4185,7 @@ int UtcDaliAnimationAnimateByActorScaleP(void)
 
   // Repeat with a different (ease-in) alpha function
   animation = Animation::New(durationSeconds);
-  animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunctions::EaseIn );
+  animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunction::EASE_IN );
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -3713,7 +4223,7 @@ int UtcDaliAnimationAnimateByActorScaleP(void)
   // Repeat with a delay
   float delay = 0.5f;
   animation = Animation::New(durationSeconds);
-  animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunctions::Linear, TimePeriod( delay, durationSeconds - delay ) );
+  animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -3735,7 +4245,7 @@ int UtcDaliAnimationAnimateByActorScaleP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToBooleaN(void)
+int UtcDaliAnimationAnimateToBooleanP(void)
 {
   TestApplication application;
 
@@ -3743,7 +4253,7 @@ int UtcDaliAnimationAnimateToBooleaN(void)
 
   // Register a boolean property
   const bool startValue(false);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
 
@@ -3817,7 +4327,7 @@ int UtcDaliAnimationAnimateToBooleaN(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToBooleanAlphaFunctioN(void)
+int UtcDaliAnimationAnimateToBooleanAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -3825,7 +4335,7 @@ int UtcDaliAnimationAnimateToBooleanAlphaFunctioN(void)
 
   // Register a boolean property
   const bool startValue(false);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
 
@@ -3833,7 +4343,7 @@ int UtcDaliAnimationAnimateToBooleanAlphaFunctioN(void)
   float durationSeconds(2.0f);
   Animation animation = Animation::New(durationSeconds);
   const bool targetValue( !startValue );
-  animation.AnimateTo(Property(actor, "test-property"), targetValue, AlphaFunctions::EaseOut);
+  animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction::EASE_OUT);
 
   // Start the animation
   animation.Play();
@@ -3867,7 +4377,7 @@ int UtcDaliAnimationAnimateToBooleanAlphaFunctioN(void)
   // Repeat with target value "false"
   animation = Animation::New(durationSeconds);
   const bool finalValue( !targetValue );
-  animation.AnimateTo(Property(actor, index), finalValue, AlphaFunctions::EaseOut);
+  animation.AnimateTo(Property(actor, index), finalValue, AlphaFunction::EASE_OUT);
 
   // Start the animation
   animation.Play();
@@ -3907,7 +4417,7 @@ int UtcDaliAnimationAnimateToBooleanTimePeriodP(void)
 
   // Register a boolean property
   bool startValue(false);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
 
@@ -3969,7 +4479,7 @@ int UtcDaliAnimationAnimateToBooleanAlphaFunctionTimePeriodP(void)
 
   // Register a boolean property
   bool startValue(false);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
 
@@ -3980,7 +4490,7 @@ int UtcDaliAnimationAnimateToBooleanAlphaFunctionTimePeriodP(void)
   float animatorDurationSeconds(durationSeconds * 0.5f);
   animation.AnimateTo( Property(actor, index),
                        finalValue,
-                       AlphaFunctions::Linear,
+                       AlphaFunction::LINEAR,
                        TimePeriod( animatorDurationSeconds ) );
 
   // Start the animation
@@ -4032,7 +4542,7 @@ int UtcDaliAnimationAnimateToFloatP(void)
 
   // Register a float property
   float startValue(10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
 
@@ -4041,7 +4551,7 @@ int UtcDaliAnimationAnimateToFloatP(void)
   Animation animation = Animation::New(durationSeconds);
   float targetValue(50.0f);
   float relativeValue(targetValue - startValue);
-  animation.AnimateTo(Property(actor, "test-property"), targetValue);
+  animation.AnimateTo(Property(actor, "testProperty"), targetValue);
 
   float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
 
@@ -4070,7 +4580,7 @@ int UtcDaliAnimationAnimateToFloatP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToFloatAlphaFunctioN(void)
+int UtcDaliAnimationAnimateToFloatAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -4078,7 +4588,7 @@ int UtcDaliAnimationAnimateToFloatAlphaFunctioN(void)
 
   // Register a float property
   float startValue(10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
 
@@ -4087,7 +4597,7 @@ int UtcDaliAnimationAnimateToFloatAlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   float targetValue(90.0f);
   float relativeValue(targetValue - startValue);
-  animation.AnimateTo(Property(actor, index), targetValue, AlphaFunctions::EaseOut);
+  animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
 
   float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
 
@@ -4127,7 +4637,7 @@ int UtcDaliAnimationAnimateToFloatTimePeriodP(void)
 
   // Register a float property
   float startValue(10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
 
@@ -4182,7 +4692,7 @@ int UtcDaliAnimationAnimateToFloatAlphaFunctionTimePeriodP(void)
 
   // Register a float property
   float startValue(10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
 
@@ -4194,7 +4704,7 @@ int UtcDaliAnimationAnimateToFloatAlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateTo(Property(actor, index),
                       targetValue,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -4238,7 +4748,7 @@ int UtcDaliAnimationAnimateToIntegerP(void)
 
   // Register an integer property
   int startValue(10);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
 
@@ -4247,7 +4757,7 @@ int UtcDaliAnimationAnimateToIntegerP(void)
   Animation animation = Animation::New(durationSeconds);
   int targetValue(50);
   int relativeValue(targetValue - startValue);
-  animation.AnimateTo(Property(actor, "test-property"), targetValue);
+  animation.AnimateTo(Property(actor, "testProperty"), targetValue);
 
   int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
 
@@ -4276,7 +4786,7 @@ int UtcDaliAnimationAnimateToIntegerP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToIntegerAlphaFunctioN(void)
+int UtcDaliAnimationAnimateToIntegerAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -4284,7 +4794,7 @@ int UtcDaliAnimationAnimateToIntegerAlphaFunctioN(void)
 
   // Register an integer property
   int startValue(10);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
 
@@ -4293,7 +4803,7 @@ int UtcDaliAnimationAnimateToIntegerAlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   int targetValue(90);
   int relativeValue(targetValue - startValue);
-  animation.AnimateTo(Property(actor, index), targetValue, AlphaFunctions::EaseOut);
+  animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
 
   int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
 
@@ -4333,7 +4843,7 @@ int UtcDaliAnimationAnimateToIntegerTimePeriodP(void)
 
   // Register an integer property
   int startValue(10);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
 
@@ -4388,7 +4898,7 @@ int UtcDaliAnimationAnimateToIntegerAlphaFunctionTimePeriodP(void)
 
   // Register an integer property
   int startValue(10);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
 
@@ -4400,7 +4910,7 @@ int UtcDaliAnimationAnimateToIntegerAlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateTo(Property(actor, index),
                       targetValue,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -4444,7 +4954,7 @@ int UtcDaliAnimationAnimateToVector2P(void)
 
   // Register a Vector2 property
   Vector2 startValue(-50.0f, -50.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
 
@@ -4482,7 +4992,7 @@ int UtcDaliAnimationAnimateToVector2P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToVector2AlphaFunctioN(void)
+int UtcDaliAnimationAnimateToVector2AlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -4490,7 +5000,7 @@ int UtcDaliAnimationAnimateToVector2AlphaFunctioN(void)
 
   // Register a Vector2 property
   Vector2 startValue(1000.0f, 1000.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
 
@@ -4499,7 +5009,7 @@ int UtcDaliAnimationAnimateToVector2AlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   Vector2 targetValue(9000.0f, 9000.0f);
   Vector2 relativeValue(targetValue - startValue);
-  animation.AnimateTo(Property(actor, "test-property"), targetValue, AlphaFunctions::EaseOut);
+  animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction::EASE_OUT);
 
   Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
 
@@ -4540,7 +5050,7 @@ int UtcDaliAnimationAnimateToVector2TimePeriodP(void)
 
   // Register a Vector2 property
   Vector2 startValue(10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
 
@@ -4595,7 +5105,7 @@ int UtcDaliAnimationAnimateToVector2AlphaFunctionTimePeriodP(void)
 
   // Register a Vector2 property
   Vector2 startValue(10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
 
@@ -4607,7 +5117,7 @@ int UtcDaliAnimationAnimateToVector2AlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateTo(Property(actor, index),
                       targetValue,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -4651,7 +5161,7 @@ int UtcDaliAnimationAnimateToVector3P(void)
 
   // Register a Vector3 property
   Vector3 startValue(-50.0f, -50.0f, -50.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
 
@@ -4689,7 +5199,7 @@ int UtcDaliAnimationAnimateToVector3P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToVector3AlphaFunctioN(void)
+int UtcDaliAnimationAnimateToVector3AlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -4697,7 +5207,7 @@ int UtcDaliAnimationAnimateToVector3AlphaFunctioN(void)
 
   // Register a Vector3 property
   Vector3 startValue(1000.0f, 1000.0f, 1000.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
 
@@ -4706,7 +5216,7 @@ int UtcDaliAnimationAnimateToVector3AlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   Vector3 targetValue(9000.0f, 9000.0f, 9000.0f);
   Vector3 relativeValue(targetValue - startValue);
-  animation.AnimateTo(Property(actor, index), targetValue, AlphaFunctions::EaseOut);
+  animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
 
   Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
 
@@ -4748,7 +5258,7 @@ int UtcDaliAnimationAnimateToVector3TimePeriodP(void)
 
   // Register a Vector3 property
   Vector3 startValue(10.0f, 10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
 
@@ -4803,7 +5313,7 @@ int UtcDaliAnimationAnimateToVector3AlphaFunctionTimePeriodP(void)
 
   // Register a Vector3 property
   Vector3 startValue(10.0f, 10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
 
@@ -4813,9 +5323,9 @@ int UtcDaliAnimationAnimateToVector3AlphaFunctionTimePeriodP(void)
   Vector3 targetValue(30.0f, 30.0f, 30.0f);
   Vector3 relativeValue(targetValue - startValue);
   float delay = 0.5f;
-  animation.AnimateTo(Property(actor, "test-property"),
+  animation.AnimateTo(Property(actor, "testProperty"),
                       targetValue,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -4859,7 +5369,7 @@ int UtcDaliAnimationAnimateToVector3ComponentP(void)
 
   // Register a Vector3 property
   Vector3 startValue(10.0f, 10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
 
@@ -4869,13 +5379,13 @@ int UtcDaliAnimationAnimateToVector3ComponentP(void)
   Vector3 targetValue(30.0f, 30.0f, 10.0f);
   Vector3 relativeValue(targetValue - startValue);
   float delay = 0.5f;
-  animation.AnimateTo(Property(actor, "test-property", 0),
+  animation.AnimateTo(Property(actor, "testProperty",  0),
                       30.0f,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
   animation.AnimateTo(Property(actor, index, 1),
                       30.0f,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -4919,7 +5429,7 @@ int UtcDaliAnimationAnimateToVector4P(void)
 
   // Register a Vector4 property
   Vector4 startValue(-50.0f, -40.0f, -30.0f, -20.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
 
@@ -4957,7 +5467,7 @@ int UtcDaliAnimationAnimateToVector4P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToVector4AlphaFunctioN(void)
+int UtcDaliAnimationAnimateToVector4AlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -4965,7 +5475,7 @@ int UtcDaliAnimationAnimateToVector4AlphaFunctioN(void)
 
   // Register a Vector4 property
   Vector4 startValue(1000.0f, 1000.0f, 1000.0f, 1000.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
 
@@ -4974,7 +5484,7 @@ int UtcDaliAnimationAnimateToVector4AlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   Vector4 targetValue(9000.0f, 9000.0f, 9000.0f, 9000.0f);
   Vector4 relativeValue(targetValue - startValue);
-  animation.AnimateTo(Property(actor, index), targetValue, AlphaFunctions::EaseOut);
+  animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
 
   Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
 
@@ -5017,7 +5527,7 @@ int UtcDaliAnimationAnimateToVector4TimePeriodP(void)
 
   // Register a Vector4 property
   Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, VECTOR4_EPSILON, TEST_LOCATION );
 
@@ -5072,7 +5582,7 @@ int UtcDaliAnimationAnimateToVector4AlphaFunctionTimePeriodP(void)
 
   // Register a Vector4 property
   Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
 
@@ -5084,7 +5594,7 @@ int UtcDaliAnimationAnimateToVector4AlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateTo(Property(actor, index),
                       targetValue,
-                      AlphaFunctions::Linear,
+                      AlphaFunction::LINEAR,
                       TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
@@ -5120,7 +5630,7 @@ int UtcDaliAnimationAnimateToVector4AlphaFunctionTimePeriodP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToActorParentOrigiN(void)
+int UtcDaliAnimationAnimateToActorParentOriginP(void)
 {
   TestApplication application;
 
@@ -5380,7 +5890,7 @@ int UtcDaliAnimationAnimateToActorSizeP(void)
 
   // Repeat with a different (ease-in) alpha function
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunctions::EaseIn);
+  animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::EASE_IN);
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -5418,7 +5928,7 @@ int UtcDaliAnimationAnimateToActorSizeP(void)
   // Repeat with a delay
   float delay = 0.5f;
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunctions::Linear, TimePeriod(delay, durationSeconds - delay));
+  animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -5472,7 +5982,6 @@ int UtcDaliAnimationAnimateToActorSizeWidthP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentSize().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*/);
@@ -5517,7 +6026,6 @@ int UtcDaliAnimationAnimateToActorSizeHeightP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentSize().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*/);
@@ -5562,7 +6070,6 @@ int UtcDaliAnimationAnimateToActorSizeDepthP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentSize().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*/);
@@ -5623,8 +6130,8 @@ int UtcDaliAnimationAnimateToActorSizeWidthHeightP(void)
 
   // Repeat with a different (ease-in) alpha function
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunctions::EaseIn );
-  animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunctions::EaseIn );
+  animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunction::EASE_IN );
+  animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunction::EASE_IN );
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -5661,8 +6168,8 @@ int UtcDaliAnimationAnimateToActorSizeWidthHeightP(void)
   // Repeat with a delay
   float delay = 0.5f;
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunctions::Linear, TimePeriod( delay, durationSeconds - delay ) );
-  animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunctions::Linear, TimePeriod( delay, durationSeconds - delay ) );
+  animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
+  animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -5685,7 +6192,7 @@ int UtcDaliAnimationAnimateToActorSizeWidthHeightP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToActorPositioN(void)
+int UtcDaliAnimationAnimateToActorPositionP(void)
 {
   TestApplication application;
 
@@ -5760,9 +6267,6 @@ int UtcDaliAnimationAnimateToActorPositionXP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentPosition().x, fiftyPercentProgress, 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*/);
@@ -5811,9 +6315,6 @@ int UtcDaliAnimationAnimateToActorPositionYP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentPosition().y, 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), 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*/);
@@ -5862,9 +6363,6 @@ int UtcDaliAnimationAnimateToActorPositionZP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   DALI_TEST_EQUALS( actor.GetCurrentPosition().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*/);
@@ -5879,7 +6377,7 @@ int UtcDaliAnimationAnimateToActorPositionZP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToActorPositionAlphaFunctioN(void)
+int UtcDaliAnimationAnimateToActorPositionAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -5891,7 +6389,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::Property::POSITION), targetPosition, AlphaFunctions::EaseIn);
+  animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::EASE_IN);
 
   Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
 
@@ -5995,7 +6493,7 @@ int UtcDaliAnimationAnimateToActorPositionAlphaFunctionTimePeriodP(void)
   float delay = 0.5f;
   animation.AnimateTo( Property(actor, Actor::Property::POSITION),
                        targetPosition,
-                       AlphaFunctions::Linear,
+                       AlphaFunction::LINEAR,
                        TimePeriod( delay, durationSeconds - delay ) );
 
   Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
@@ -6090,7 +6588,7 @@ int UtcDaliAnimationAnimateToActorOrientationAngleAxisP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToActorOrientationQuaternioN(void)
+int UtcDaliAnimationAnimateToActorOrientationQuaternionP(void)
 {
   TestApplication application;
 
@@ -6148,7 +6646,7 @@ int UtcDaliAnimationAnimateToActorOrientationQuaternioN(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToActorOrientationAlphaFunctioN(void)
+int UtcDaliAnimationAnimateToActorOrientationAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -6162,7 +6660,7 @@ int UtcDaliAnimationAnimateToActorOrientationAlphaFunctioN(void)
   Animation animation = Animation::New(durationSeconds);
   Degree targetRotationDegrees(90.0f);
   Radian targetRotationRadians(targetRotationDegrees);
-  animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunctions::EaseIn);
+  animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN);
 
   // Start the animation
   animation.Play();
@@ -6177,7 +6675,7 @@ int UtcDaliAnimationAnimateToActorOrientationAlphaFunctioN(void)
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(0.25f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.25f*0.25f*0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
@@ -6185,7 +6683,7 @@ int UtcDaliAnimationAnimateToActorOrientationAlphaFunctioN(void)
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(0.5f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.5f*0.5f*0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
@@ -6193,7 +6691,7 @@ int UtcDaliAnimationAnimateToActorOrientationAlphaFunctioN(void)
   // We didn't expect the animation to finish yet
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(0.75f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.75f*0.75f*0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
@@ -6281,7 +6779,7 @@ int UtcDaliAnimationAnimateToActorOrientationAlphaFunctionTimePeriodP(void)
   Degree targetRotationDegrees(90.0f);
   Radian targetRotationRadians(targetRotationDegrees);
   float delay(0.1f);
-  animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunctions::EaseIn, TimePeriod(delay, durationSeconds - delay));
+  animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN, TimePeriod(delay, durationSeconds - delay));
 
   // Start the animation
   animation.Play();
@@ -6297,7 +6795,7 @@ int UtcDaliAnimationAnimateToActorOrientationAlphaFunctionTimePeriodP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
@@ -6306,7 +6804,7 @@ int UtcDaliAnimationAnimateToActorOrientationAlphaFunctionTimePeriodP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
@@ -6315,7 +6813,7 @@ int UtcDaliAnimationAnimateToActorOrientationAlphaFunctionTimePeriodP(void)
   application.SendNotification();
   finishCheck.CheckSignalNotReceived();
   progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
-  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
@@ -6375,7 +6873,7 @@ int UtcDaliAnimationAnimateToActorScaleP(void)
 
   // Repeat with a different (ease-in) alpha function
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunctions::EaseIn);
+  animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::EASE_IN);
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -6413,7 +6911,7 @@ int UtcDaliAnimationAnimateToActorScaleP(void)
   // Repeat with a delay
   float delay = 0.5f;
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunctions::Linear, TimePeriod(delay, durationSeconds - delay));
+  animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -6637,7 +7135,7 @@ int UtcDaliAnimationAnimateToActorColorP(void)
 
   // Repeat with a different (ease-in) alpha function
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunctions::EaseIn);
+  animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::EASE_IN);
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -6675,7 +7173,7 @@ int UtcDaliAnimationAnimateToActorColorP(void)
   // Repeat with a shorter animator duration
   float animatorDuration = 0.5f;
   animation = Animation::New(durationSeconds);
-  animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunctions::Linear, TimePeriod(animatorDuration));
+  animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::LINEAR, TimePeriod(animatorDuration));
   animation.FinishedSignal().Connect(&application, finishCheck);
   animation.Play();
 
@@ -6759,7 +7257,7 @@ int UtcDaliAnimationAnimateToActorColorRedP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateToActorColorGreeN(void)
+int UtcDaliAnimationAnimateToActorColorGreenP(void)
 {
   TestApplication application;
 
@@ -6929,6 +7427,33 @@ int UtcDaliAnimationKeyFrames01P(void)
   DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
 
   keyFrames.Add(0.0f, 0.1f);
+
+  DALI_TEST_EQUALS(keyFrames.GetType(), Property::FLOAT, TEST_LOCATION);
+
+  KeyFrames keyFrames2( keyFrames);
+  DALI_TEST_CHECK( keyFrames2 );
+  DALI_TEST_EQUALS(keyFrames2.GetType(), Property::FLOAT, TEST_LOCATION);
+
+  KeyFrames keyFrames3 = KeyFrames::New();
+  keyFrames3.Add(0.6f, true);
+  DALI_TEST_CHECK( keyFrames3 );
+  DALI_TEST_EQUALS(keyFrames3.GetType(), Property::BOOLEAN, TEST_LOCATION);
+
+  keyFrames3 = keyFrames;
+  DALI_TEST_CHECK( keyFrames3 );
+  DALI_TEST_EQUALS(keyFrames3.GetType(), Property::FLOAT, TEST_LOCATION);
+
+  END_TEST;
+}
+
+int UtcDaliAnimationKeyFrames02P(void)
+{
+  TestApplication application;
+
+  KeyFrames keyFrames = KeyFrames::New();
+  DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
+
+  keyFrames.Add(0.0f, 0.1f);
   keyFrames.Add(0.2f, 0.5f);
   keyFrames.Add(0.4f, 0.0f);
   keyFrames.Add(0.6f, 1.0f);
@@ -6949,7 +7474,7 @@ int UtcDaliAnimationKeyFrames01P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationKeyFrames02P(void)
+int UtcDaliAnimationKeyFrames03P(void)
 {
   TestApplication application;
 
@@ -6977,7 +7502,7 @@ int UtcDaliAnimationKeyFrames02P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationKeyFrames03P(void)
+int UtcDaliAnimationKeyFrames04P(void)
 {
   TestApplication application;
 
@@ -7005,7 +7530,7 @@ int UtcDaliAnimationKeyFrames03P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationKeyFrames04P(void)
+int UtcDaliAnimationKeyFrames05P(void)
 {
   TestApplication application;
 
@@ -7033,7 +7558,7 @@ int UtcDaliAnimationKeyFrames04P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationKeyFrames05P(void)
+int UtcDaliAnimationKeyFrames06P(void)
 {
   TestApplication application;
 
@@ -7061,7 +7586,7 @@ int UtcDaliAnimationKeyFrames05P(void)
   END_TEST;
 }
 
-int UtcDaliAnimationKeyFrames06P(void)
+int UtcDaliAnimationKeyFrames07P(void)
 {
   TestApplication application;
 
@@ -7738,7 +8263,7 @@ int UtcDaliAnimationAnimateBetweenActorOrientation02CubicP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctioN(void)
+int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -7762,7 +8287,7 @@ int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctioN(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::Property::COLOR), keyFrames, AlphaFunctions::Linear );
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR );
 
   // Start the animation
   animation.Play();
@@ -7837,7 +8362,7 @@ int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionCubicP(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::Property::COLOR), keyFrames, AlphaFunctions::Linear, Animation::Cubic );
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, Animation::Cubic );
 
   // Start the animation
   animation.Play();
@@ -8067,7 +8592,7 @@ int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionTimePeriodP(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::Property::COLOR), keyFrames, AlphaFunctions::Linear, TimePeriod( delay, durationSeconds - delay ) );
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
 
   // Start the animation
   animation.Play();
@@ -8119,7 +8644,7 @@ int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionTimePeriodP(void)
   END_TEST;
 }
 
-int P(void)
+int UtcDaliAnimationAnimateBetweenActorColorCubicWithDelayP(void)
 {
   TestApplication application;
 
@@ -8144,7 +8669,7 @@ int P(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::Property::COLOR), keyFrames, AlphaFunctions::Linear, TimePeriod( delay, durationSeconds - delay ), Animation::Cubic );
+  animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ), Animation::Cubic );
 
   // Start the animation
   animation.Play();
@@ -8275,7 +8800,7 @@ int UtcDaliAnimationAnimateP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationAnimateAlphaFunctioN(void)
+int UtcDaliAnimationAnimateAlphaFunctionP(void)
 {
   TestApplication application;
 
@@ -8303,7 +8828,7 @@ int UtcDaliAnimationAnimateAlphaFunctioN(void)
   // Build the animation
   float durationSeconds( 1.0f );
   Animation animation = Animation::New(durationSeconds);
-  animation.Animate(actor, path, Vector3::XAXIS, AlphaFunctions::Linear);
+  animation.Animate(actor, path, Vector3::XAXIS, AlphaFunction::LINEAR);
 
   // Start the animation
   animation.Play();
@@ -8461,7 +8986,7 @@ int UtcDaliAnimationAnimateAlphaFunctionTimePeriodP(void)
   // 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));
+  animation.Animate(actor, path, Vector3::XAXIS, AlphaFunction::LINEAR, TimePeriod(0.0f, 1.0f));
 
   // Start the animation
   animation.Play();
@@ -8720,12 +9245,12 @@ int UtcDaliAnimationUpdateManagerP(void)
   animation.FinishedSignal().Connect( &application, finishCheck );
 
   Vector3 startValue(1.0f, 1.0f, 1.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Constraint constraint = Constraint::New<Vector3>( actor, index, UpdateManagerTestConstraint( application ) );
   constraint.Apply();
 
   // Apply animation to actor
-  animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 100.f, 90.f, 80.f ), AlphaFunctions::Linear );
+  animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 100.f, 90.f, 80.f ), AlphaFunction::LINEAR );
 
   animation.Play();
 
@@ -8759,9 +9284,9 @@ int UtcDaliAnimationSignalOrderP(void)
   animation2.FinishedSignal().Connect( &application, AnimationFinishCheck( signal2Received ) );
 
   // Apply animations to actor
-  animation1.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 3.0f, 2.0f, 1.0f ), AlphaFunctions::Linear );
+  animation1.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 3.0f, 2.0f, 1.0f ), AlphaFunction::LINEAR );
   animation1.Play();
-  animation2.AnimateTo( Property(actor, Actor::Property::SIZE ), Vector3( 10.0f, 20.0f, 30.0f ), AlphaFunctions::Linear );
+  animation2.AnimateTo( Property(actor, Actor::Property::SIZE ), Vector3( 10.0f, 20.0f, 30.0f ), AlphaFunction::LINEAR );
   animation2.Play();
 
   DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
@@ -8794,7 +9319,7 @@ int UtcDaliAnimationSignalOrderP(void)
   END_TEST;
 }
 
-int UtcDaliAnimationExtendDuratioN(void)
+int UtcDaliAnimationExtendDurationP(void)
 {
   TestApplication application;
 
@@ -8802,7 +9327,7 @@ int UtcDaliAnimationExtendDuratioN(void)
 
   // Register a float property
   float startValue(10.0f);
-  Property::Index index = actor.RegisterProperty( "test-property", startValue );
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
   Stage::GetCurrent().Add(actor);
   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
 
@@ -8854,3 +9379,44 @@ int UtcDaliAnimationExtendDuratioN(void)
   DALI_TEST_EQUALS( actor.GetProperty<float>(index), targetValue, TEST_LOCATION );
   END_TEST;
 }
+
+int UtcDaliAnimationCustomIntProperty(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  Stage::GetCurrent().Add(actor);
+  int startValue(0u);
+
+  Property::Index index = actor.RegisterProperty("anIndex",  startValue);
+  DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
+
+  // Build the animation
+  float durationSeconds(1.0f);
+  Animation animation = Animation::New(durationSeconds);
+  animation.AnimateTo( Property(actor, index), 20 );
+
+  // 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% progress */);
+
+  // We didn't expect the animation to finish yet
+  application.SendNotification();
+  finishCheck.CheckSignalNotReceived();
+  DALI_TEST_EQUALS( actor.GetProperty<int>(index), 10, 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.GetProperty<int>(index), 20, TEST_LOCATION );
+  END_TEST;
+}