Renamed TouchSignal to TouchedSignal

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

diff --git a/automated-tests/src/dali/utc-Dali-Actor.cpp b/automated-tests/src/dali/utc-Dali-Actor.cpp
index 34ef21c..01419e2 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-Actor.cpp
+++ b/automated-tests/src/dali/utc-Dali-Actor.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,6 +15,9 @@
  *
  */
 
+// Enable debug log for test coverage
+#define DEBUG_ENABLED 1
+
 #include "assert.h"
 #include <dali/public-api/dali-core.h>
 #include <string>
@@ -22,6 +25,7 @@
 #include <dali/devel-api/actors/actor-devel.h>
 #include <dali/integration-api/events/touch-event-integ.h>
 #include <dali/integration-api/events/hover-event-integ.h>
+#include <dali/integration-api/debug.h>
 #include <dali-test-suite-utils.h>
 #include <mesh-builder.h>
 
@@ -51,6 +55,8 @@ bool gHoverCallBackCalled=false;
 
 static bool gTestConstraintCalled;
 
+LayoutDirection::Type gLayoutDirectionType;
+
 struct TestConstraint
 {
   void operator()( Vector4& color, const PropertyInputContainer& /* inputs */ )
@@ -82,28 +88,22 @@ struct TestConstraintRef
   unsigned int mValue;
 };
 
-static bool TestCallback(Actor actor, const TouchEvent& event)
-{
-  gTouchCallBackCalled = true;
-  return false;
-  END_TEST;
-}
 
-static bool TestTouchCallback(Actor actor, const TouchData& touchData )
+static bool TestTouchCallback(Actor, const TouchEvent&)
 {
   gTouchCallBackCalled = true;
   return true;
   END_TEST;
 }
 
-static bool TestTouchCallback2(Actor actor, const TouchData& touchData )
+static bool TestTouchCallback2(Actor, const TouchEvent&)
 {
   gTouchCallBackCalled2 = true;
   return true;
   END_TEST;
 }
 
-static bool TestTouchCallback3(Actor actor, const TouchData& touchData )
+static bool TestTouchCallback3(Actor, const TouchEvent&)
 {
   gTouchCallBackCalled3 = true;
   return true;
@@ -125,20 +125,20 @@ static bool TestCallback3(Actor actor, const HoverEvent& event)
 }
 
 // validation stuff for onstage & offstage signals
-static std::vector< std::string > gActorNamesOnOffStage;
-static int gOnStageCallBackCalled;
-void OnStageCallback( Actor actor )
+static std::vector< std::string > gActorNamesOnOffScene;
+static int gOnSceneCallBackCalled;
+void OnSceneCallback( Actor actor )
 {
-  ++gOnStageCallBackCalled;
-  gActorNamesOnOffStage.push_back( actor.GetName() );
-  DALI_TEST_CHECK( actor.OnStage() == true );
+  ++gOnSceneCallBackCalled;
+  gActorNamesOnOffScene.push_back( actor.GetProperty< std::string >( Actor::Property::NAME ) );
+  DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) == true );
 }
-static int gOffStageCallBackCalled;
-void OffStageCallback( Actor actor )
+static int gOffSceneCallBackCalled;
+void OffSceneCallback( Actor actor )
 {
-  ++gOffStageCallBackCalled;
-  gActorNamesOnOffStage.push_back( actor.GetName() );
-  DALI_TEST_CHECK( actor.OnStage() == false );
+  ++gOffSceneCallBackCalled;
+  gActorNamesOnOffScene.push_back( actor.GetProperty< std::string >( Actor::Property::NAME ) );
+  DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) == false );
 }
 
 struct PositionComponentConstraint
@@ -174,7 +174,7 @@ static std::vector< std::string > gActorNamesRelayout;
 void OnRelayoutCallback( Actor actor )
 {
   gOnRelayoutCallBackCalled = true;
-  gActorNamesRelayout.push_back( actor.GetName() );
+  gActorNamesRelayout.push_back( actor.GetProperty< std::string >( Actor::Property::NAME ) );
 }
 
 struct VisibilityChangedFunctorData
@@ -229,6 +229,55 @@ struct VisibilityChangedFunctor
   VisibilityChangedFunctorData& data;
 };
 
+
+struct VisibilityChangedVoidFunctor
+{
+  VisibilityChangedVoidFunctor(bool& signalCalled)
+  : mSignalCalled( signalCalled )
+  { }
+
+  void operator()()
+  {
+    mSignalCalled  = true;
+  }
+
+  bool& mSignalCalled;
+};
+
+struct ChildOrderChangedFunctor
+{
+  ChildOrderChangedFunctor(bool& signalCalled, Actor& actor)
+  : mSignalCalled( signalCalled ),
+    mActor( actor )
+  { }
+
+  void operator()( Actor actor )
+  {
+    mSignalCalled  = true;
+    mActor = actor;
+  }
+
+  bool& mSignalCalled;
+  Actor& mActor;
+};
+
+struct CulledPropertyNotificationFunctor
+{
+  CulledPropertyNotificationFunctor( bool& signalCalled, PropertyNotification& propertyNotification )
+  : mSignalCalled( signalCalled ),
+    mPropertyNotification( propertyNotification )
+  { }
+
+  void operator()( PropertyNotification& source )
+  {
+    mSignalCalled  = true;
+    mPropertyNotification = source;
+  }
+
+  bool& mSignalCalled;
+  PropertyNotification& mPropertyNotification;
+};
+
 } // anonymous namespace
 
 
@@ -268,6 +317,41 @@ int UtcDaliActorDownCastN(void)
   END_TEST;
 }
 
+int UtcDaliActorMoveConstructor(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  DALI_TEST_CHECK( actor );
+
+  int id = actor.GetProperty< int >( Actor::Property::ID );
+
+  Actor moved = std::move( actor);
+  DALI_TEST_CHECK( moved );
+  DALI_TEST_EQUALS( id, moved.GetProperty< int >( Actor::Property::ID ), TEST_LOCATION );
+  DALI_TEST_CHECK( !actor );
+
+  END_TEST;
+}
+
+int UtcDaliActorMoveAssignment(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  DALI_TEST_CHECK( actor );
+
+  int id = actor.GetProperty< int >( Actor::Property::ID );
+
+  Actor moved;
+  moved = std::move( actor);
+  DALI_TEST_CHECK( moved );
+  DALI_TEST_EQUALS( id, moved.GetProperty< int >( Actor::Property::ID ), TEST_LOCATION );
+  DALI_TEST_CHECK( !actor );
+
+  END_TEST;
+}
+
 //& purpose: Testing Dali::Actor::GetName()
 int UtcDaliActorGetName(void)
 {
@@ -275,7 +359,7 @@ int UtcDaliActorGetName(void)
 
   Actor actor = Actor::New();
 
-  DALI_TEST_CHECK(actor.GetName().empty());
+  DALI_TEST_CHECK(actor.GetProperty< std::string >( Actor::Property::NAME ).empty());
   END_TEST;
 }
 
@@ -287,22 +371,22 @@ int UtcDaliActorSetName(void)
   string str("ActorName");
   Actor actor = Actor::New();
 
-  actor.SetName(str);
-  DALI_TEST_CHECK(actor.GetName() == str);
+  actor.SetProperty( Actor::Property::NAME,str);
+  DALI_TEST_CHECK(actor.GetProperty< std::string >( Actor::Property::NAME ) == str);
   END_TEST;
 }
 
 int UtcDaliActorGetId(void)
 {
-  tet_infoline("Testing Dali::Actor::UtcDaliActorGetId()");
+  tet_infoline("Testing Dali::Actor::UtcDaliActo.GetProperty< int >( Actor::Property::ID )");
   TestApplication application;
 
   Actor first = Actor::New();
   Actor second = Actor::New();
   Actor third = Actor::New();
 
-  DALI_TEST_CHECK(first.GetId() != second.GetId());
-  DALI_TEST_CHECK(second.GetId() != third.GetId());
+  DALI_TEST_CHECK(first.GetProperty< int >( Actor::Property::ID ) != second.GetProperty< int >( Actor::Property::ID ));
+  DALI_TEST_CHECK(second.GetProperty< int >( Actor::Property::ID ) != third.GetProperty< int >( Actor::Property::ID ));
   END_TEST;
 }
 
@@ -311,24 +395,24 @@ int UtcDaliActorIsRoot(void)
   TestApplication application;
 
   Actor actor = Actor::New();
-  DALI_TEST_CHECK(!actor.IsRoot());
+  DALI_TEST_CHECK(!actor.GetProperty< bool >( Actor::Property::IS_ROOT ));
 
   // get the root layer
-  actor = Stage::GetCurrent().GetLayer( 0 );
-  DALI_TEST_CHECK( actor.IsRoot() );
+  actor = application.GetScene().GetLayer( 0 );
+  DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::IS_ROOT ) );
   END_TEST;
 }
 
-int UtcDaliActorOnStage(void)
+int UtcDaliActorOnScene(void)
 {
   TestApplication application;
 
   Actor actor = Actor::New();
-  DALI_TEST_CHECK( !actor.OnStage() );
+  DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
 
   // get the root layer
-  actor = Stage::GetCurrent().GetLayer( 0 );
-  DALI_TEST_CHECK( actor.OnStage() );
+  actor = application.GetScene().GetLayer( 0 );
+  DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
   END_TEST;
 }
 
@@ -337,11 +421,11 @@ int UtcDaliActorIsLayer(void)
   TestApplication application;
 
   Actor actor = Actor::New();
-  DALI_TEST_CHECK( !actor.IsLayer() );
+  DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::IS_LAYER ) );
 
   // get the root layer
-  actor = Stage::GetCurrent().GetLayer( 0 );
-  DALI_TEST_CHECK( actor.IsLayer() );
+  actor = application.GetScene().GetLayer( 0 );
+  DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::IS_LAYER ) );
   END_TEST;
 }
 
@@ -350,13 +434,13 @@ int UtcDaliActorGetLayer(void)
   TestApplication application;
 
   Actor actor = Actor::New();
-  Stage::GetCurrent().Add(actor);
+  application.GetScene().Add(actor);
   Layer layer = actor.GetLayer();
 
   DALI_TEST_CHECK(layer);
 
   // get the root layers layer
-  actor = Stage::GetCurrent().GetLayer( 0 );
+  actor = application.GetScene().GetLayer( 0 );
   DALI_TEST_CHECK( actor.GetLayer() );
   END_TEST;
 }
@@ -430,7 +514,7 @@ int UtcDaliActorAddN(void)
   // try reparenting root
   try
   {
-    parent2.Add( Stage::GetCurrent().GetLayer( 0 ) );
+    parent2.Add( application.GetScene().GetLayer( 0 ) );
     tet_printf("Assertion test failed - no Exception\n" );
     tet_result(TET_FAIL);
   }
@@ -525,7 +609,7 @@ int UtcDaliActorRemoveP(void)
   Actor child = Actor::New();
   Actor random = Actor::New();
 
-  Stage::GetCurrent().Add( parent );
+  application.GetScene().Add( parent );
 
   DALI_TEST_CHECK(parent.GetChildCount() == 0);
 
@@ -537,7 +621,7 @@ int UtcDaliActorRemoveP(void)
 
   DALI_TEST_CHECK(parent.GetChildCount() == 1);
 
-  Stage::GetCurrent().Remove( parent );
+  application.GetScene().Remove( parent );
 
   DALI_TEST_CHECK(parent.GetChildCount() == 1);
   END_TEST;
@@ -621,6 +705,75 @@ int UtcDaliActorGetParent02(void)
   END_TEST;
 }
 
+int UtcDaliActorCustomProperty(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  application.GetScene().Add( actor );
+
+  float startValue(1.0f);
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
+  DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+
+  actor.SetProperty( index, 5.0f );
+
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_CHECK( actor.GetProperty<float>(index) == 5.0f );
+  END_TEST;
+}
+
+int UtcDaliActorCustomPropertyIntToFloat(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  application.GetScene().Add( actor );
+
+  float startValue(5.0f);
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
+  DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+
+  actor.SetProperty( index, int(1) );
+
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_CHECK( actor.GetProperty<float>(index) == 1.0f );
+  END_TEST;
+}
+
+int UtcDaliActorCustomPropertyFloatToInt(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  application.GetScene().Add( actor );
+
+  int startValue(5);
+  Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
+  DALI_TEST_CHECK( actor.GetProperty<int>(index) == startValue );
+
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_CHECK( actor.GetProperty<int>(index) == startValue );
+
+  actor.SetProperty( index, float(1.5) );
+
+  application.SendNotification();
+  application.Render(0);
+  DALI_TEST_CHECK( actor.GetProperty<int>(index) == 1 );
+  END_TEST;
+}
+
 int UtcDaliActorSetParentOrigin(void)
 {
   TestApplication application;
@@ -628,27 +781,27 @@ int UtcDaliActorSetParentOrigin(void)
   Actor actor = Actor::New();
 
   Vector3 vector(0.7f, 0.8f, 0.9f);
-  DALI_TEST_CHECK(vector != actor.GetCurrentParentOrigin());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ));
 
-  actor.SetParentOrigin(vector);
+  actor.SetProperty( Actor::Property::PARENT_ORIGIN, vector );
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentParentOrigin());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ));
 
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
 
-  actor.SetParentOrigin( Vector3( 0.1f, 0.2f, 0.3f ) );
+  actor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3( 0.1f, 0.2f, 0.3f ) );
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentParentOrigin(), TEST_LOCATION );
+  DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), TEST_LOCATION );
 
-  Stage::GetCurrent().Remove( actor );
+  application.GetScene().Remove( actor );
   END_TEST;
 }
 
@@ -659,7 +812,7 @@ int UtcDaliActorSetParentOriginIndividual(void)
   Actor actor = Actor::New();
 
   Vector3 vector(0.7f, 0.8f, 0.9f);
-  DALI_TEST_CHECK(vector != actor.GetCurrentParentOrigin());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ));
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN_X, vector.x );
 
@@ -667,7 +820,7 @@ int UtcDaliActorSetParentOriginIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.x, actor.GetCurrentParentOrigin().x, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ).x, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN_Y, vector.y );
 
@@ -675,7 +828,7 @@ int UtcDaliActorSetParentOriginIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.y, actor.GetCurrentParentOrigin().y, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ).y, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN_Z, vector.z );
 
@@ -683,7 +836,7 @@ int UtcDaliActorSetParentOriginIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.z, actor.GetCurrentParentOrigin().z, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ).z, TEST_LOCATION );
 
   END_TEST;
 }
@@ -695,15 +848,15 @@ int UtcDaliActorGetCurrentParentOrigin(void)
   Actor actor = Actor::New();
 
   Vector3 vector(0.7f, 0.8f, 0.9f);
-  DALI_TEST_CHECK(vector != actor.GetCurrentParentOrigin());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ));
 
-  actor.SetParentOrigin(vector);
+  actor.SetProperty( Actor::Property::PARENT_ORIGIN, vector );
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentParentOrigin());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ));
   END_TEST;
 }
 
@@ -714,26 +867,26 @@ int UtcDaliActorSetAnchorPoint(void)
   Actor actor = Actor::New();
 
   Vector3 vector(0.7f, 0.8f, 0.9f);
-  DALI_TEST_CHECK(vector != actor.GetCurrentAnchorPoint());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ));
 
-  actor.SetAnchorPoint(vector);
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, vector );
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentAnchorPoint());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ));
 
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
 
-  actor.SetAnchorPoint( Vector3( 0.1f, 0.2f, 0.3f ) );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, Vector3( 0.1f, 0.2f, 0.3f ) );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentAnchorPoint(), TEST_LOCATION );
+  DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), TEST_LOCATION );
 
-  Stage::GetCurrent().Remove( actor );
+  application.GetScene().Remove( actor );
   END_TEST;
 }
 
@@ -744,7 +897,7 @@ int UtcDaliActorSetAnchorPointIndividual(void)
   Actor actor = Actor::New();
 
   Vector3 vector(0.7f, 0.8f, 0.9f);
-  DALI_TEST_CHECK(vector != actor.GetCurrentAnchorPoint());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ));
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT_X, vector.x );
 
@@ -752,7 +905,7 @@ int UtcDaliActorSetAnchorPointIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.x, actor.GetCurrentAnchorPoint().x, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ).x, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT_Y, vector.y );
 
@@ -760,7 +913,7 @@ int UtcDaliActorSetAnchorPointIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.y, actor.GetCurrentAnchorPoint().y, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ).y, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT_Z, vector.z );
 
@@ -768,7 +921,7 @@ int UtcDaliActorSetAnchorPointIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.z, actor.GetCurrentAnchorPoint().z, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ).z, TEST_LOCATION );
 
   END_TEST;
 }
@@ -780,19 +933,18 @@ int UtcDaliActorGetCurrentAnchorPoint(void)
   Actor actor = Actor::New();
 
   Vector3 vector(0.7f, 0.8f, 0.9f);
-  DALI_TEST_CHECK(vector != actor.GetCurrentAnchorPoint());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ));
 
-  actor.SetAnchorPoint(vector);
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, vector);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentAnchorPoint());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ));
   END_TEST;
 }
 
-// SetSize(float width, float height)
 int UtcDaliActorSetSize01(void)
 {
   TestApplication application;
@@ -800,9 +952,9 @@ int UtcDaliActorSetSize01(void)
   Actor actor = Actor::New();
   Vector3 vector(100.0f, 100.0f, 0.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
-  actor.SetSize(vector.x, vector.y);
+  actor.SetProperty( Actor::Property::SIZE, Vector2( vector.x, vector.y ) );
 
   // Immediately retrieve the size after setting
   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
@@ -816,7 +968,7 @@ int UtcDaliActorSetSize01(void)
   application.Render();
 
   // Check the size in the new frame
-  DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
@@ -838,7 +990,7 @@ int UtcDaliActorSetSize01(void)
   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
 
   // Set a new size after resize policy is changed and check the new size
-  actor.SetSize( Vector3( 0.1f, 0.2f, 0.0f ) );
+  actor.SetProperty( Actor::Property::SIZE, Vector3( 0.1f, 0.2f, 0.0f ) );
 
   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
@@ -850,7 +1002,7 @@ int UtcDaliActorSetSize01(void)
   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
 
   // Set another new size after resize policy is changed and check the new size
-  actor.SetSize( Vector3( 50.0f, 60.0f, 0.0f ) );
+  actor.SetProperty( Actor::Property::SIZE, Vector3( 50.0f, 60.0f, 0.0f ) );
 
   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
   DALI_TEST_EQUALS( currentSize, Vector3( 50.0f, 60.0f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
@@ -858,7 +1010,6 @@ int UtcDaliActorSetSize01(void)
   END_TEST;
 }
 
-// SetSize(float width, float height, float depth)
 int UtcDaliActorSetSize02(void)
 {
   TestApplication application;
@@ -866,9 +1017,9 @@ int UtcDaliActorSetSize02(void)
   Actor actor = Actor::New();
   Vector3 vector(100.0f, 100.0f, 100.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
-  actor.SetSize(vector.x, vector.y, vector.z);
+  actor.SetProperty( Actor::Property::SIZE, Vector3( vector.x, vector.y, vector.z ) );
 
   // Immediately check the size after setting
   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
@@ -879,7 +1030,7 @@ int UtcDaliActorSetSize02(void)
   application.Render();
 
   // Check the size in the new frame
-  DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
@@ -895,9 +1046,9 @@ int UtcDaliActorSetSize03(void)
   Actor actor = Actor::New();
   Vector3 vector(100.0f, 100.0f, 0.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
-  actor.SetSize(Vector2(vector.x, vector.y));
+  actor.SetProperty( Actor::Property::SIZE,Vector2(vector.x, vector.y));
 
   // Immediately check the size after setting
   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
@@ -908,7 +1059,7 @@ int UtcDaliActorSetSize03(void)
   application.Render();
 
   // Check the size in the new frame
-  DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
   DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
@@ -924,9 +1075,9 @@ int UtcDaliActorSetSize04(void)
   Actor actor = Actor::New();
   Vector3 vector(100.0f, 100.0f, 100.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
-  actor.SetSize(vector);
+  actor.SetProperty( Actor::Property::SIZE,vector);
 
   // Immediately check the size after setting
   Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
@@ -937,10 +1088,10 @@ int UtcDaliActorSetSize04(void)
   application.Render();
 
   // Check the size in the new frame
-  DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
-  Stage::GetCurrent().Add( actor );
-  actor.SetSize( Vector3( 0.1f, 0.2f, 0.3f ) );
+  application.GetScene().Add( actor );
+  actor.SetProperty( Actor::Property::SIZE, Vector3( 0.1f, 0.2f, 0.3f ) );
 
   // Immediately check the size after setting
   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
@@ -951,12 +1102,12 @@ int UtcDaliActorSetSize04(void)
   application.Render();
 
   // Check the size in the new frame
-  DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentSize(), TEST_LOCATION );
+  DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), TEST_LOCATION );
 
   currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
   DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.3f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
 
-  Stage::GetCurrent().Remove( actor );
+  application.GetScene().Remove( actor );
   END_TEST;
 }
 
@@ -967,7 +1118,7 @@ int UtcDaliActorSetSizeIndividual(void)
   Actor actor = Actor::New();
 
   Vector3 vector(0.7f, 0.8f, 0.9f);
-  DALI_TEST_CHECK(vector != actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
   actor.SetProperty( Actor::Property::SIZE_WIDTH, vector.width );
 
@@ -980,7 +1131,7 @@ int UtcDaliActorSetSizeIndividual(void)
   application.Render();
 
   // Check the width in the new frame
-  DALI_TEST_EQUALS( vector.width, actor.GetCurrentSize().width, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.width, actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).width, TEST_LOCATION );
 
   sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
   DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
@@ -996,7 +1147,7 @@ int UtcDaliActorSetSizeIndividual(void)
   application.Render();
 
   // Check the height in the new frame
-  DALI_TEST_EQUALS( vector.height, actor.GetCurrentSize().height, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.height, actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).height, TEST_LOCATION );
 
   sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
   DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
@@ -1012,7 +1163,7 @@ int UtcDaliActorSetSizeIndividual(void)
   application.Render();
 
   // Check the depth in the new frame
-  DALI_TEST_EQUALS( vector.depth, actor.GetCurrentSize().depth, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.depth, actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).depth, TEST_LOCATION );
 
   sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
   DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
@@ -1050,10 +1201,10 @@ int UtcDaliActorSetSizeIndividual02(void)
 
   Actor actor = Actor::New();
   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
 
   Vector3 vector( 100.0f, 200.0f, 400.0f );
-  DALI_TEST_CHECK( vector != actor.GetCurrentSize() );
+  DALI_TEST_CHECK( vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ) );
 
   actor.SetProperty( Actor::Property::SIZE_WIDTH, vector.width );
   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >(), vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
@@ -1069,8 +1220,8 @@ int UtcDaliActorSetSizeIndividual02(void)
   application.Render();
 
   // Check the width in the new frame
-  DALI_TEST_EQUALS( vector.width, actor.GetCurrentSize().width, TEST_LOCATION );
-  DALI_TEST_EQUALS( vector.height, actor.GetCurrentSize().height, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.width, actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).width, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.height, actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).height, TEST_LOCATION );
 
   END_TEST;
 }
@@ -1083,15 +1234,15 @@ int UtcDaliActorGetCurrentSize(void)
   Actor actor = Actor::New();
   Vector3 vector(100.0f, 100.0f, 20.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
-  actor.SetSize(vector);
+  actor.SetProperty( Actor::Property::SIZE,vector);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
   END_TEST;
 }
 
@@ -1115,19 +1266,19 @@ int UtcDaliActorGetCurrentSizeImmediate(void)
   Vector3 vector(100.0f, 100.0f, 20.0f);
 
   DALI_TEST_CHECK(vector != actor.GetTargetSize());
-  DALI_TEST_CHECK(vector != actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
-  actor.SetSize(vector);
+  actor.SetProperty( Actor::Property::SIZE,vector);
 
   DALI_TEST_CHECK(vector == actor.GetTargetSize());
-  DALI_TEST_CHECK(vector != actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
   DALI_TEST_CHECK(vector == actor.GetTargetSize());
-  DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
 
   // Animation
   // Build the animation
@@ -1149,6 +1300,29 @@ int UtcDaliActorGetCurrentSizeImmediate(void)
   END_TEST;
 }
 
+int UtcDaliActorCalculateScreenExtents(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+
+  actor.SetProperty( Actor::Property::POSITION, Vector3(2.0f, 2.0f, 16.0f));
+  actor.SetProperty( Actor::Property::SIZE,Vector3{ 1.0f, 1.0f, 1.0f });
+
+  application.SendNotification();
+  application.Render();
+
+  auto expectedExtent = Rect<>{ -0.5f, -0.5f, 1.0f, 1.0f };
+  auto actualExtent = DevelActor::CalculateScreenExtents( actor );
+  DALI_TEST_EQUALS( expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+  DALI_TEST_EQUALS( expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+  DALI_TEST_EQUALS( expectedExtent.width, actualExtent.width, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+  DALI_TEST_EQUALS( expectedExtent.height, actualExtent.height, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+
+  application.GetScene().Remove( actor );
+  END_TEST;
+}
+
 // SetPosition(float x, float y)
 int UtcDaliActorSetPosition01(void)
 {
@@ -1157,40 +1331,40 @@ int UtcDaliActorSetPosition01(void)
   Actor actor = Actor::New();
 
   // Set to random to start off with
-  actor.SetPosition(Vector3(120.0f, 120.0f, 0.0f));
+  actor.SetProperty( Actor::Property::POSITION, Vector3(120.0f, 120.0f, 0.0f));
 
   Vector3 vector(100.0f, 100.0f, 0.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
 
-  actor.SetPosition(vector.x, vector.y);
+  actor.SetProperty( Actor::Property::POSITION, Vector2(vector.x, vector.y));
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
 
-  Stage::GetCurrent().Add( actor );
-  actor.SetPosition( Vector3( 0.1f, 0.2f, 0.3f ) );
+  application.GetScene().Add( actor );
+  actor.SetProperty( Actor::Property::POSITION, Vector3( 0.1f, 0.2f, 0.3f ) );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentPosition(), TEST_LOCATION );
+  DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
 
-  actor.SetX( 1.0f );
-  actor.SetY( 1.1f );
-  actor.SetZ( 1.2f );
+  actor.SetProperty( Actor::Property::POSITION_X,  1.0f );
+  actor.SetProperty( Actor::Property::POSITION_Y,  1.1f );
+  actor.SetProperty( Actor::Property::POSITION_Z,  1.2f );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( Vector3( 1.0f, 1.1f, 1.2f ), actor.GetCurrentPosition(), TEST_LOCATION );
+  DALI_TEST_EQUALS( Vector3( 1.0f, 1.1f, 1.2f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
 
   actor.TranslateBy( Vector3( 0.1f, 0.1f, 0.1f ) );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( Vector3( 1.1f, 1.2f, 1.3f ), actor.GetCurrentPosition(), Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+  DALI_TEST_EQUALS( Vector3( 1.1f, 1.2f, 1.3f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Math::MACHINE_EPSILON_10000, TEST_LOCATION );
 
-  Stage::GetCurrent().Remove( actor );
+  application.GetScene().Remove( actor );
   END_TEST;
 }
 
@@ -1202,19 +1376,19 @@ int UtcDaliActorSetPosition02(void)
   Actor actor = Actor::New();
 
   // Set to random to start off with
-  actor.SetPosition(Vector3(120.0f, 120.0f, 120.0f));
+  actor.SetProperty( Actor::Property::POSITION, Vector3(120.0f, 120.0f, 120.0f));
 
   Vector3 vector(100.0f, 100.0f, 100.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
 
-  actor.SetPosition(vector.x, vector.y, vector.z);
+  actor.SetProperty( Actor::Property::POSITION, Vector3(vector.x, vector.y, vector.z));
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
   END_TEST;
 }
 
@@ -1226,19 +1400,19 @@ int UtcDaliActorSetPosition03(void)
   Actor actor = Actor::New();
 
   // Set to random to start off with
-  actor.SetPosition(Vector3(120.0f, 120.0f, 120.0f));
+  actor.SetProperty( Actor::Property::POSITION, Vector3(120.0f, 120.0f, 120.0f));
 
   Vector3 vector(100.0f, 100.0f, 100.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
 
-  actor.SetPosition(vector);
+  actor.SetProperty( Actor::Property::POSITION, vector);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
   END_TEST;
 }
 
@@ -1250,15 +1424,15 @@ int UtcDaliActorSetX(void)
 
   Vector3 vector(100.0f, 0.0f, 0.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
 
-  actor.SetX(100.0f);
+  actor.SetProperty( Actor::Property::POSITION_X, 100.0f);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
   END_TEST;
 }
 
@@ -1270,15 +1444,15 @@ int UtcDaliActorSetY(void)
 
   Vector3 vector(0.0f, 100.0f, 0.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
 
-  actor.SetY(100.0f);
+  actor.SetProperty( Actor::Property::POSITION_Y, 100.0f);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
   END_TEST;
 }
 
@@ -1290,15 +1464,15 @@ int UtcDaliActorSetZ(void)
 
   Vector3 vector(0.0f, 0.0f, 100.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
 
-  actor.SetZ(100.0f);
+  actor.SetProperty( Actor::Property::POSITION_Z, 100.0f);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
   END_TEST;
 }
 
@@ -1309,7 +1483,7 @@ int UtcDaliActorSetPositionProperties(void)
   Actor actor = Actor::New();
 
   Vector3 vector(0.7f, 0.8f, 0.9f);
-  DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
 
   actor.SetProperty( Actor::Property::POSITION_X, vector.x );
   DALI_TEST_EQUALS( vector.x, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
@@ -1319,7 +1493,7 @@ int UtcDaliActorSetPositionProperties(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.x, actor.GetCurrentPosition().x, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.x, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
@@ -1333,7 +1507,7 @@ int UtcDaliActorSetPositionProperties(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.y, actor.GetCurrentPosition().y, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.y, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
@@ -1347,7 +1521,7 @@ int UtcDaliActorSetPositionProperties(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.z, actor.GetCurrentPosition().z, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.z, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
@@ -1363,15 +1537,15 @@ int UtcDaliActorTranslateBy(void)
   Actor actor = Actor::New();
   Vector3 vector(100.0f, 100.0f, 100.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
 
-  actor.SetPosition(vector);
+  actor.SetProperty( Actor::Property::POSITION, vector);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
 
   actor.TranslateBy(vector);
 
@@ -1379,7 +1553,7 @@ int UtcDaliActorTranslateBy(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector*2.0f == actor.GetCurrentPosition());
+  DALI_TEST_CHECK(vector*2.0f == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
   END_TEST;
 }
 
@@ -1389,13 +1563,13 @@ int UtcDaliActorGetCurrentPosition(void)
 
   Actor actor = Actor::New();
   Vector3 setVector(100.0f, 100.0f, 0.0f);
-  actor.SetPosition(setVector);
+  actor.SetProperty( Actor::Property::POSITION, setVector);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(actor.GetCurrentPosition() == setVector);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ) == setVector);
   END_TEST;
 }
 
@@ -1405,138 +1579,124 @@ int UtcDaliActorGetCurrentWorldPosition(void)
 
   Actor parent = Actor::New();
   Vector3 parentPosition( 1.0f, 2.0f, 3.0f );
-  parent.SetPosition( parentPosition );
-  parent.SetParentOrigin( ParentOrigin::CENTER );
-  parent.SetAnchorPoint( AnchorPoint::CENTER );
-  Stage::GetCurrent().Add( parent );
+  parent.SetProperty( Actor::Property::POSITION, parentPosition );
+  parent.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  parent.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
-  child.SetParentOrigin( ParentOrigin::CENTER );
-  child.SetAnchorPoint( AnchorPoint::CENTER );
+  child.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  child.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
   Vector3 childPosition( 6.0f, 6.0f, 6.0f );
-  child.SetPosition( childPosition );
+  child.SetProperty( Actor::Property::POSITION, childPosition );
   parent.Add( child );
 
   // The actors should not have a world position yet
-  DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3::ZERO, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3::ZERO, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(0);
 
-  DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentPosition(), childPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), parentPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), childPosition, TEST_LOCATION );
 
   // The actors should have a world position now
-  DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition + childPosition, TEST_LOCATION );
   END_TEST;
 }
 
-int UtcDaliActorInheritPosition(void)
+int UtcDaliActorSetInheritPosition(void)
 {
-  tet_infoline("Testing Actor::SetPositionInheritanceMode");
+  tet_infoline("Testing Actor::SetInheritPosition");
   TestApplication application;
 
   Actor parent = Actor::New();
   Vector3 parentPosition( 1.0f, 2.0f, 3.0f );
-  parent.SetPosition( parentPosition );
-  parent.SetParentOrigin( ParentOrigin::CENTER );
-  parent.SetAnchorPoint( AnchorPoint::CENTER );
-  Stage::GetCurrent().Add( parent );
+  parent.SetProperty( Actor::Property::POSITION, parentPosition );
+  parent.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  parent.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
-  child.SetParentOrigin( ParentOrigin::CENTER );
-  child.SetAnchorPoint( AnchorPoint::CENTER );
+  child.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  child.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
   Vector3 childPosition( 10.0f, 11.0f, 12.0f );
-  child.SetPosition( childPosition );
+  child.SetProperty( Actor::Property::POSITION, childPosition );
   parent.Add( child );
 
   // The actors should not have a world position yet
-  DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3::ZERO, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3::ZERO, TEST_LOCATION );
 
   // first test default, which is to inherit position
-  DALI_TEST_EQUALS( child.GetPositionInheritanceMode(), Dali::INHERIT_PARENT_POSITION, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_POSITION ), true, TEST_LOCATION );
   application.SendNotification();
   application.Render(0); // should only really call Update as Render is not required to update scene
-  DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentPosition(), childPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childPosition, TEST_LOCATION );
-
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), parentPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), childPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition + childPosition, TEST_LOCATION );
 
   //Change child position
   Vector3 childOffset( -1.0f, 1.0f, 0.0f );
-  child.SetPosition( childOffset );
+  child.SetProperty( Actor::Property::POSITION, childOffset );
+
+  // Use local position as world postion
+  child.SetProperty( Actor::Property::INHERIT_POSITION, false );
+  DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_POSITION ), false, TEST_LOCATION );
+  application.SendNotification();
+  application.Render(0); // should only really call Update as Render is not required to update scene
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), parentPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), childOffset, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), childOffset, TEST_LOCATION );
 
-  // Change inheritance mode to not inherit
-  child.SetPositionInheritanceMode( Dali::DONT_INHERIT_POSITION );
-  DALI_TEST_EQUALS( child.GetPositionInheritanceMode(), Dali::DONT_INHERIT_POSITION, TEST_LOCATION );
+  //Change back to inherit position from parent
+  child.SetProperty( Actor::Property::INHERIT_POSITION, true );
+  DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_POSITION ), true, TEST_LOCATION );
   application.SendNotification();
   application.Render(0); // should only really call Update as Render is not required to update scene
-  DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentPosition(), childOffset, TEST_LOCATION );
-  DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), childOffset, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), parentPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), childOffset, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition + childOffset, TEST_LOCATION );
   END_TEST;
 }
 
-int UtcDaliActorSetInheritPosition(void)
+int UtcDaliActorInheritOpacity(void)
 {
-  tet_infoline("Testing Actor::SetInheritPosition");
+  tet_infoline("Testing Actor::Inherit Opacity");
   TestApplication application;
 
   Actor parent = Actor::New();
-  Vector3 parentPosition( 1.0f, 2.0f, 3.0f );
-  parent.SetPosition( parentPosition );
-  parent.SetParentOrigin( ParentOrigin::CENTER );
-  parent.SetAnchorPoint( AnchorPoint::CENTER );
-  Stage::GetCurrent().Add( parent );
-
   Actor child = Actor::New();
-  child.SetParentOrigin( ParentOrigin::CENTER );
-  child.SetAnchorPoint( AnchorPoint::CENTER );
-  Vector3 childPosition( 10.0f, 11.0f, 12.0f );
-  child.SetPosition( childPosition );
   parent.Add( child );
+  application.GetScene().Add( parent );
 
-  // The actors should not have a world position yet
-  DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), Vector3::ZERO, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
 
-  // first test default, which is to inherit position
-  DALI_TEST_EQUALS( child.IsPositionInherited(), true, TEST_LOCATION );
+  // flush the queue and render once
   application.SendNotification();
-  application.Render(0); // should only really call Update as Render is not required to update scene
-  DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentPosition(), childPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childPosition, TEST_LOCATION );
+  application.Render();
 
-  //Change child position
-  Vector3 childOffset( -1.0f, 1.0f, 0.0f );
-  child.SetPosition( childOffset );
+  parent.SetProperty( Actor::Property::OPACITY, 0.1f );
 
-  // Use local position as world postion
-  child.SetInheritPosition( false );
-  DALI_TEST_EQUALS( child.IsPositionInherited(), false, TEST_LOCATION );
-  application.SendNotification();
-  application.Render(0); // should only really call Update as Render is not required to update scene
-  DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentPosition(), childOffset, TEST_LOCATION );
-  DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), childOffset, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
 
-  //Change back to inherit position from parent
-  child.SetInheritPosition( true );
-  DALI_TEST_EQUALS( child.IsPositionInherited(), true, TEST_LOCATION );
   application.SendNotification();
-  application.Render(0); // should only really call Update as Render is not required to update scene
-  DALI_TEST_EQUALS( parent.GetCurrentPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentPosition(), childOffset, TEST_LOCATION );
-  DALI_TEST_EQUALS( parent.GetCurrentWorldPosition(), parentPosition, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldPosition(), parentPosition + childOffset, TEST_LOCATION );
+  application.Render();
+
+  DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.f, 0.0001f, TEST_LOCATION );
+
   END_TEST;
 }
 
@@ -1548,13 +1708,13 @@ int UtcDaliActorSetOrientation01(void)
   Quaternion rotation( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
   Actor actor = Actor::New();
 
-  actor.SetOrientation(rotation);
+  actor.SetProperty( Actor::Property::ORIENTATION, rotation);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
   END_TEST;
 }
 
@@ -1567,31 +1727,31 @@ int UtcDaliActorSetOrientation02(void)
   Radian angle( 0.785f );
   Vector3 axis(1.0f, 1.0f, 0.0f);
 
-  actor.SetOrientation( angle, axis);
+  actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( angle, axis ) );
   Quaternion rotation( angle, axis );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
 
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
   actor.RotateBy( Degree( 360 ), axis);
-  DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
 
-  actor.SetOrientation( Degree( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) );
+  actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Degree( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) ) );
   Quaternion result( Radian( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( result, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS( result, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
 
-  actor.SetOrientation( angle, axis);
+  actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( angle, axis ) );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
 
-  Stage::GetCurrent().Remove( actor );
+  application.GetScene().Remove( actor );
   END_TEST;
 }
 
@@ -1610,7 +1770,7 @@ int UtcDaliActorSetOrientationProperty(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
   DALI_TEST_EQUALS(rotation, actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
   DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
   END_TEST;
@@ -1628,17 +1788,17 @@ int UtcDaliActorRotateBy01(void)
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(Quaternion( angle, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(Quaternion( angle, Vector3::ZAXIS), actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
 
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
 
   actor.RotateBy( angle, Vector3::ZAXIS);
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
 
-  Stage::GetCurrent().Remove( actor );
+  application.GetScene().Remove( actor );
   END_TEST;
 }
 
@@ -1655,13 +1815,13 @@ int UtcDaliActorRotateBy02(void)
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
 
   actor.RotateBy(rotation);
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
   END_TEST;
 }
 
@@ -1671,11 +1831,11 @@ int UtcDaliActorGetCurrentOrientation(void)
   Actor actor = Actor::New();
 
   Quaternion rotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
-  actor.SetOrientation(rotation);
+  actor.SetProperty( Actor::Property::ORIENTATION, rotation );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(rotation, actor.GetCurrentOrientation(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
   END_TEST;
 }
 
@@ -1687,36 +1847,36 @@ int UtcDaliActorGetCurrentWorldOrientation(void)
   Actor parent = Actor::New();
   Radian rotationAngle( Degree(90.0f) );
   Quaternion rotation( rotationAngle, Vector3::YAXIS );
-  parent.SetOrientation( rotation );
-  Stage::GetCurrent().Add( parent );
+  parent.SetProperty( Actor::Property::ORIENTATION, rotation );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
-  child.SetOrientation( rotation );
+  child.SetProperty( Actor::Property::ORIENTATION, rotation );
   parent.Add( child );
 
   // The actors should not have a world rotation yet
-  DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(0);
 
-  DALI_TEST_EQUALS( parent.GetCurrentOrientation(), rotation, 0.001, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentOrientation(), rotation, 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, 0.001, TEST_LOCATION );
 
   // The actors should have a world rotation now
-  DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), Quaternion( rotationAngle * 2.0f, Vector3::YAXIS ), 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion( rotationAngle * 2.0f, Vector3::YAXIS ), 0.001, TEST_LOCATION );
 
   // turn off child rotation inheritance
-  child.SetInheritOrientation( false );
-  DALI_TEST_EQUALS( child.IsOrientationInherited(), false, TEST_LOCATION );
+  child.SetProperty( Actor::Property::INHERIT_ORIENTATION, false );
+  DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION ), false, TEST_LOCATION );
   application.SendNotification();
   application.Render(0);
 
   // The actors should have a world rotation now
-  DALI_TEST_EQUALS( parent.GetCurrentWorldOrientation(), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldOrientation(), rotation, 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), rotation, 0.001, TEST_LOCATION );
   END_TEST;
 }
 
@@ -1727,19 +1887,19 @@ int UtcDaliActorSetScale01(void)
 
   Actor actor = Actor::New();
 
-  // Set to random value first - GetCurrentScale() asserts if called before SetScale()
-  actor.SetScale(0.25f);
+  // Set to random value first -.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) asserts if called before SetScale()
+  actor.SetProperty( Actor::Property::SCALE,0.25f);
 
   Vector3 scale(10.0f, 10.0f, 10.0f);
-  DALI_TEST_CHECK(actor.GetCurrentScale() != scale);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) != scale);
 
-  actor.SetScale(scale.x);
+  actor.SetProperty( Actor::Property::SCALE,scale.x);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) == scale);
   END_TEST;
 }
 
@@ -1751,26 +1911,26 @@ int UtcDaliActorSetScale02(void)
 
   Actor actor = Actor::New();
 
-  // Set to random value first - GetCurrentScale() asserts if called before SetScale()
-  actor.SetScale(Vector3(12.0f, 1.0f, 2.0f));
+  // Set to random value first -.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) asserts if called before SetScale()
+  actor.SetProperty( Actor::Property::SCALE, Vector3( 12.0f, 1.0f, 2.0f ) );
 
-  DALI_TEST_CHECK(actor.GetCurrentScale() != scale);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) != scale);
 
-  actor.SetScale(scale.x, scale.y, scale.z);
+  actor.SetProperty( Actor::Property::SCALE, Vector3( scale.x, scale.y, scale.z ) );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) == scale);
 
   // add to stage and test
-  Stage::GetCurrent().Add( actor );
-  actor.SetScale( 2.0f, 2.0f, 2.0f );
+  application.GetScene().Add( actor );
+  actor.SetProperty( Actor::Property::SCALE, Vector3( 2.0f, 2.0f, 2.0f ) );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( Vector3( 2.0f, 2.0f, 2.0f ), actor.GetCurrentScale(), 0.001, TEST_LOCATION);
+  DALI_TEST_EQUALS( Vector3( 2.0f, 2.0f, 2.0f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), 0.001, TEST_LOCATION);
 
-  Stage::GetCurrent().Remove( actor );
+  application.GetScene().Remove( actor );
 
   END_TEST;
 }
@@ -1783,18 +1943,18 @@ int UtcDaliActorSetScale03(void)
 
   Actor actor = Actor::New();
 
-  // Set to random value first - GetCurrentScale() asserts if called before SetScale()
-  actor.SetScale(Vector3(12.0f, 1.0f, 2.0f));
+  // Set to random value first -.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) asserts if called before SetScale()
+  actor.SetProperty( Actor::Property::SCALE, Vector3(12.0f, 1.0f, 2.0f));
 
-  DALI_TEST_CHECK(actor.GetCurrentScale() != scale);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) != scale);
 
-  actor.SetScale(scale);
+  actor.SetProperty( Actor::Property::SCALE,scale);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) == scale);
   END_TEST;
 }
 
@@ -1805,7 +1965,7 @@ int UtcDaliActorSetScaleIndividual(void)
   Actor actor = Actor::New();
 
   Vector3 vector(0.7f, 0.8f, 0.9f);
-  DALI_TEST_CHECK(vector != actor.GetCurrentScale());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ));
 
   actor.SetProperty( Actor::Property::SCALE_X, vector.x );
   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
@@ -1814,7 +1974,7 @@ int UtcDaliActorSetScaleIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.x, actor.GetCurrentScale().x, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).x, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
 
@@ -1825,7 +1985,7 @@ int UtcDaliActorSetScaleIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.y, actor.GetCurrentScale().y, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).y, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
 
@@ -1836,7 +1996,7 @@ int UtcDaliActorSetScaleIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.z, actor.GetCurrentScale().z, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).z, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
 
@@ -1852,15 +2012,15 @@ int UtcDaliActorScaleBy(void)
   Actor actor = Actor::New();
   Vector3 vector(100.0f, 100.0f, 100.0f);
 
-  DALI_TEST_CHECK(vector != actor.GetCurrentScale());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ));
 
-  actor.SetScale(vector);
+  actor.SetProperty( Actor::Property::SCALE,vector);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector == actor.GetCurrentScale());
+  DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ));
 
   actor.ScaleBy(vector);
 
@@ -1868,7 +2028,7 @@ int UtcDaliActorScaleBy(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(vector*100.0f == actor.GetCurrentScale());
+  DALI_TEST_CHECK(vector*100.0f == actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ));
   END_TEST;
 }
 
@@ -1879,13 +2039,13 @@ int UtcDaliActorGetCurrentScale(void)
 
   Actor actor = Actor::New();
 
-  actor.SetScale(scale);
+  actor.SetProperty( Actor::Property::SCALE,scale);
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_CHECK(actor.GetCurrentScale() == scale);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) == scale);
   END_TEST;
 }
 
@@ -1895,31 +2055,31 @@ int UtcDaliActorGetCurrentWorldScale(void)
 
   Actor parent = Actor::New();
   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
-  parent.SetScale( parentScale );
-  Stage::GetCurrent().Add( parent );
+  parent.SetProperty( Actor::Property::SCALE, parentScale );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
   Vector3 childScale( 2.0f, 2.0f, 2.0f );
-  child.SetScale( childScale );
+  child.SetProperty( Actor::Property::SCALE, childScale );
   parent.Add( child );
 
   // The actors should not have a scale yet
-  DALI_TEST_EQUALS( parent.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
 
   // The actors should not have a world scale yet
-  DALI_TEST_EQUALS( parent.GetCurrentWorldScale(), Vector3::ONE, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldScale(), Vector3::ONE, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), Vector3::ONE, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), Vector3::ONE, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(0);
 
-  DALI_TEST_EQUALS( parent.GetCurrentScale(), parentScale, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentScale(), childScale, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), parentScale, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), childScale, TEST_LOCATION );
 
   // The actors should have a world scale now
-  DALI_TEST_EQUALS( parent.GetCurrentWorldScale(), parentScale, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldScale(), parentScale * childScale, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), parentScale, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), parentScale * childScale, TEST_LOCATION );
   END_TEST;
 }
 
@@ -1930,27 +2090,27 @@ int UtcDaliActorInheritScale(void)
 
   Actor parent = Actor::New();
   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
-  parent.SetScale( parentScale );
-  Stage::GetCurrent().Add( parent );
+  parent.SetProperty( Actor::Property::SCALE, parentScale );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
   Vector3 childScale( 2.0f, 2.0f, 2.0f );
-  child.SetScale( childScale );
+  child.SetProperty( Actor::Property::SCALE, childScale );
   parent.Add( child );
 
   application.SendNotification();
   application.Render(0);
 
-  DALI_TEST_EQUALS( child.IsScaleInherited(), true, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldScale(), parentScale * childScale, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_SCALE ), true, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), parentScale * childScale, TEST_LOCATION );
 
-  child.SetInheritScale( false );
-  DALI_TEST_EQUALS( child.IsScaleInherited(), false, TEST_LOCATION );
+  child.SetProperty( Actor::Property::INHERIT_SCALE, false );
+  DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_SCALE ), false, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(0);
 
-  DALI_TEST_EQUALS( child.GetCurrentWorldScale(), childScale, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), childScale, TEST_LOCATION );
   END_TEST;
 }
 
@@ -1959,25 +2119,25 @@ int UtcDaliActorSetVisible(void)
   TestApplication application;
 
   Actor actor = Actor::New();
-  actor.SetVisible(false);
+  actor.SetProperty( Actor::Property::VISIBLE,false);
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_CHECK(actor.IsVisible() == false);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == false);
 
-  actor.SetVisible(true);
+  actor.SetProperty( Actor::Property::VISIBLE,true);
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_CHECK(actor.IsVisible() == true);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == true);
 
   // put actor on stage
-  Stage::GetCurrent().Add( actor );
-  actor.SetVisible(false);
+  application.GetScene().Add( actor );
+  actor.SetProperty( Actor::Property::VISIBLE,false);
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_CHECK(actor.IsVisible() == false);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == false);
   END_TEST;
 }
 
@@ -1987,7 +2147,7 @@ int UtcDaliActorIsVisible(void)
 
   Actor actor = Actor::New();
 
-  DALI_TEST_CHECK(actor.IsVisible() == true);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == true);
   END_TEST;
 }
 
@@ -1997,38 +2157,38 @@ int UtcDaliActorSetOpacity(void)
 
   Actor actor = Actor::New();
   // initial opacity is 1
-  DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 1.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 1.0f, TEST_LOCATION );
 
-  actor.SetOpacity( 0.4f);
+  actor.SetProperty( Actor::Property::OPACITY, 0.4f);
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.4f, TEST_LOCATION );
+  DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.4f, TEST_LOCATION );
 
   // change opacity, actor is on stage to change is not immediate
-  actor.SetOpacity( actor.GetCurrentOpacity() + 0.1f );
+  actor.SetProperty( Actor::Property::OPACITY, actor.GetCurrentProperty< float >( Actor::Property::OPACITY ) + 0.1f );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.5f, TEST_LOCATION );
+  DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.5f, TEST_LOCATION );
 
   // put actor on stage
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
 
   // change opacity, actor is on stage to change is not immediate
-  actor.SetOpacity( 0.9f );
-  DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.5f, TEST_LOCATION );
+  actor.SetProperty( Actor::Property::OPACITY, 0.9f );
+  DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.5f, TEST_LOCATION );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.9f, TEST_LOCATION );
+  DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.9f, TEST_LOCATION );
 
   // change opacity, actor is on stage to change is not immediate
-  actor.SetOpacity( actor.GetCurrentOpacity() - 0.9f );
+  actor.SetProperty( Actor::Property::OPACITY, actor.GetCurrentProperty< float >( Actor::Property::OPACITY ) - 0.9f );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS(actor.GetCurrentOpacity(), 0.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.0f, TEST_LOCATION );
   END_TEST;
 }
 
@@ -2037,13 +2197,13 @@ int UtcDaliActorGetCurrentOpacity(void)
   TestApplication application;
 
   Actor actor = Actor::New();
-  DALI_TEST_CHECK(actor.GetCurrentOpacity() != 0.5f);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ) != 0.5f);
 
-  actor.SetOpacity(0.5f);
+  actor.SetProperty( Actor::Property::OPACITY,0.5f);
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_CHECK(actor.GetCurrentOpacity() == 0.5f);
+  DALI_TEST_CHECK(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ) == 0.5f);
   END_TEST;
 }
 
@@ -2052,11 +2212,11 @@ int UtcDaliActorSetSensitive(void)
   TestApplication application;
   Actor actor = Actor::New();
 
-  bool sensitive = !actor.IsSensitive();
+  bool sensitive = !actor.GetProperty< bool >( Actor::Property::SENSITIVE );
 
-  actor.SetSensitive(sensitive);
+  actor.SetProperty( Actor::Property::SENSITIVE,sensitive);
 
-  DALI_TEST_CHECK(sensitive == actor.IsSensitive());
+  DALI_TEST_CHECK(sensitive == actor.GetProperty< bool >( Actor::Property::SENSITIVE ));
   END_TEST;
 }
 
@@ -2064,9 +2224,9 @@ int UtcDaliActorIsSensitive(void)
 {
   TestApplication application;
   Actor actor = Actor::New();
-  actor.SetSensitive(false);
+  actor.SetProperty( Actor::Property::SENSITIVE,false);
 
-  DALI_TEST_CHECK(false == actor.IsSensitive());
+  DALI_TEST_CHECK(false == actor.GetProperty< bool >( Actor::Property::SENSITIVE ));
   END_TEST;
 }
 
@@ -2076,37 +2236,44 @@ int UtcDaliActorSetColor(void)
   Actor actor = Actor::New();
   Vector4 color(1.0f, 1.0f, 1.0f, 0.5f);
 
-  DALI_TEST_CHECK(color != actor.GetCurrentColor());
+  DALI_TEST_CHECK(color != actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ));
 
-  actor.SetColor(color);
+  actor.SetProperty( Actor::Property::COLOR,color);
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_CHECK(color == actor.GetCurrentColor());
+  DALI_TEST_CHECK(color == actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ));
 
-  actor.SetColor( actor.GetCurrentColor() + Vector4( -0.4f, -0.5f, -0.6f, -0.4f ) );
+  actor.SetProperty( Actor::Property::COLOR, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ) + Vector4( -0.4f, -0.5f, -0.6f, -0.4f ) );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( Vector4( 0.6f, 0.5f, 0.4f, 0.1f ), actor.GetCurrentColor(),  TEST_LOCATION );
+  DALI_TEST_EQUALS( Vector4( 0.6f, 0.5f, 0.4f, 0.1f ), actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ),  TEST_LOCATION );
 
-  Stage::GetCurrent().Add( actor );
-  actor.SetColor( color );
+  application.GetScene().Add( actor );
+  actor.SetProperty( Actor::Property::COLOR, color );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( color, actor.GetCurrentColor(),  TEST_LOCATION );
+  DALI_TEST_EQUALS( color, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ),  TEST_LOCATION );
 
-  actor.SetColor( actor.GetCurrentColor() + Vector4( 1.1f, 1.1f, 1.1f, 1.1f ) );
+  actor.SetProperty( Actor::Property::COLOR, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ) + Vector4( 1.1f, 1.1f, 1.1f, 1.1f ) );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
   // Actor color is not clamped
-  DALI_TEST_EQUALS( Vector4( 2.1f, 2.1f, 2.1f, 1.6f ), actor.GetCurrentColor(),  TEST_LOCATION );
+  DALI_TEST_EQUALS( Vector4( 2.1f, 2.1f, 2.1f, 1.6f ), actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ),  TEST_LOCATION );
   // world color is clamped
-  DALI_TEST_EQUALS( Vector4( 1.0f, 1.0f, 1.0f, 1.0f ), actor.GetCurrentWorldColor(),  TEST_LOCATION );
+  DALI_TEST_EQUALS( Vector4( 1.0f, 1.0f, 1.0f, 1.0f ), actor.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ),  TEST_LOCATION );
 
-  Stage::GetCurrent().Remove( actor );
+  actor.SetProperty( Actor::Property::COLOR, color );
+  DALI_TEST_EQUALS( color, actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
+
+  Vector3 newColor( 1.0f, 0.0f, 0.0f );
+  actor.SetProperty( Actor::Property::COLOR, newColor );
+  DALI_TEST_EQUALS( Vector4( newColor.r, newColor.g, newColor.b, 1.0f ), actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
+
+  application.GetScene().Remove( actor );
   END_TEST;
 }
 
@@ -2117,7 +2284,7 @@ int UtcDaliActorSetColorIndividual(void)
   Actor actor = Actor::New();
 
   Vector4 vector(0.7f, 0.8f, 0.9f, 0.6f);
-  DALI_TEST_CHECK(vector != actor.GetCurrentColor());
+  DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ));
 
   actor.SetProperty( Actor::Property::COLOR_RED, vector.r );
   DALI_TEST_EQUALS( vector.r, actor.GetProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
@@ -2126,7 +2293,7 @@ int UtcDaliActorSetColorIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.r, actor.GetCurrentColor().r, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.r, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).r, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.r, actor.GetProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector.r, actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
 
@@ -2137,7 +2304,7 @@ int UtcDaliActorSetColorIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.g, actor.GetCurrentColor().g, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.g, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).g, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.g, actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector.g, actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
 
@@ -2148,7 +2315,7 @@ int UtcDaliActorSetColorIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.b, actor.GetCurrentColor().b, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.b, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).b, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.b, actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector.b, actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
 
@@ -2160,21 +2327,21 @@ int UtcDaliActorSetColorIndividual(void)
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( vector.a, actor.GetCurrentColor().a, TEST_LOCATION );
+  DALI_TEST_EQUALS( vector.a, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, TEST_LOCATION );
   DALI_TEST_EQUALS( vector.a, actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector.a, actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
 
   DALI_TEST_EQUALS( vector, actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
   DALI_TEST_EQUALS( vector, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
 
-  actor.SetProperty( DevelActor::Property::OPACITY, 0.2f );
+  actor.SetProperty( Actor::Property::OPACITY, 0.2f );
 
 
   // flush the queue and render once
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( 0.2f, actor.GetCurrentColor().a, TEST_LOCATION );
+  DALI_TEST_EQUALS( 0.2f, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, TEST_LOCATION );
 
   END_TEST;
 }
@@ -2186,11 +2353,11 @@ int UtcDaliActorGetCurrentColor(void)
   Actor actor = Actor::New();
   Vector4 color(1.0f, 1.0f, 1.0f, 0.5f);
 
-  actor.SetColor(color);
+  actor.SetProperty( Actor::Property::COLOR,color);
   // flush the queue and render once
   application.SendNotification();
   application.Render();
-  DALI_TEST_CHECK(color == actor.GetCurrentColor());
+  DALI_TEST_CHECK(color == actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ));
   END_TEST;
 }
 
@@ -2201,55 +2368,55 @@ int UtcDaliActorGetCurrentWorldColor(void)
 
   Actor parent = Actor::New();
   Vector4 parentColor( 1.0f, 0.5f, 0.0f, 0.8f );
-  parent.SetColor( parentColor );
-  Stage::GetCurrent().Add( parent );
+  parent.SetProperty( Actor::Property::COLOR, parentColor );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
   Vector4 childColor( 0.5f, 0.6f, 0.5f, 1.0f );
-  child.SetColor( childColor );
+  child.SetProperty( Actor::Property::COLOR, childColor );
   parent.Add( child );
 
-  DALI_TEST_EQUALS( parent.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
 
   // verify the default color mode
-  DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_ALPHA, child.GetColorMode(), TEST_LOCATION );
+  DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_ALPHA, child.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), TEST_LOCATION );
 
   // The actors should not have a world color yet
-  DALI_TEST_EQUALS( parent.GetCurrentWorldColor(), Color::WHITE, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldColor(), Color::WHITE, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), Color::WHITE, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), Color::WHITE, TEST_LOCATION );
 
   application.SendNotification();
   application.Render(0);
 
-  DALI_TEST_EQUALS( parent.GetCurrentColor(), parentColor, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentColor(), childColor, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), parentColor, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), childColor, TEST_LOCATION );
 
   // The actors should have a world color now
-  DALI_TEST_EQUALS( parent.GetCurrentWorldColor(), parentColor, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldColor(), Vector4( childColor.r, childColor.g, childColor.b, childColor.a * parentColor.a), TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), parentColor, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), Vector4( childColor.r, childColor.g, childColor.b, childColor.a * parentColor.a), TEST_LOCATION );
 
   // use own color
-  child.SetColorMode( USE_OWN_COLOR );
+  child.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_COLOR );
   application.SendNotification();
   application.Render(0);
-  DALI_TEST_EQUALS( child.GetCurrentWorldColor(), childColor, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), childColor, TEST_LOCATION );
 
   // use parent color
-  child.SetColorMode( USE_PARENT_COLOR );
+  child.SetProperty( Actor::Property::COLOR_MODE, USE_PARENT_COLOR );
   application.SendNotification();
   application.Render(0);
-  DALI_TEST_EQUALS( child.GetCurrentColor(), childColor, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldColor(), parentColor, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), childColor, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), parentColor, TEST_LOCATION );
 
   // use parent alpha
-  child.SetColorMode( USE_OWN_MULTIPLY_PARENT_ALPHA );
+  child.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA );
   application.SendNotification();
   application.Render(0);
   Vector4 expectedColor( childColor );
   expectedColor.a *= parentColor.a;
-  DALI_TEST_EQUALS( child.GetCurrentColor(), childColor, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldColor(), expectedColor, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), childColor, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), expectedColor, TEST_LOCATION );
   END_TEST;
 }
 
@@ -2261,17 +2428,17 @@ int UtcDaliActorSetColorMode(void)
   Actor child = Actor::New();
   actor.Add( child );
 
-  actor.SetColorMode( USE_OWN_COLOR );
-  DALI_TEST_EQUALS( USE_OWN_COLOR, actor.GetColorMode(), TEST_LOCATION );
+  actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_COLOR );
+  DALI_TEST_EQUALS( USE_OWN_COLOR, actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), TEST_LOCATION );
 
-  actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_COLOR );
-  DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_COLOR, actor.GetColorMode(), TEST_LOCATION );
+  actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR );
+  DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_COLOR, actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), TEST_LOCATION );
 
-  actor.SetColorMode( USE_PARENT_COLOR );
-  DALI_TEST_EQUALS( USE_PARENT_COLOR, actor.GetColorMode(), TEST_LOCATION );
+  actor.SetProperty( Actor::Property::COLOR_MODE, USE_PARENT_COLOR );
+  DALI_TEST_EQUALS( USE_PARENT_COLOR, actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), TEST_LOCATION );
 
-  actor.SetColorMode( USE_OWN_MULTIPLY_PARENT_ALPHA );
-  DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_ALPHA, actor.GetColorMode(), TEST_LOCATION );
+  actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA );
+  DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_ALPHA, actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), TEST_LOCATION );
   END_TEST;
 }
 
@@ -2279,10 +2446,10 @@ int UtcDaliActorScreenToLocal(void)
 {
   TestApplication application;
   Actor actor = Actor::New();
-  actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
-  actor.SetSize(100.0f, 100.0f);
-  actor.SetPosition(10.0f, 10.0f);
-  Stage::GetCurrent().Add(actor);
+  actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+  actor.SetProperty( Actor::Property::POSITION, Vector2(10.0f, 10.0f));
+  application.GetScene().Add(actor);
 
   // flush the queue and render once
   application.SendNotification();
@@ -2307,11 +2474,11 @@ int UtcDaliActorSetLeaveRequired(void)
 
   Actor actor = Actor::New();
 
-  actor.SetLeaveRequired(false);
-  DALI_TEST_CHECK(actor.GetLeaveRequired() == false);
+  actor.SetProperty( Actor::Property::LEAVE_REQUIRED,false);
+  DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::LEAVE_REQUIRED ) == false);
 
-  actor.SetLeaveRequired(true);
-  DALI_TEST_CHECK(actor.GetLeaveRequired() == true);
+  actor.SetProperty( Actor::Property::LEAVE_REQUIRED,true);
+  DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::LEAVE_REQUIRED ) == true);
   END_TEST;
 }
 
@@ -2321,7 +2488,7 @@ int UtcDaliActorGetLeaveRequired(void)
 
   Actor actor = Actor::New();
 
-  DALI_TEST_CHECK(actor.GetLeaveRequired() == false);
+  DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::LEAVE_REQUIRED ) == false);
   END_TEST;
 }
 
@@ -2331,11 +2498,11 @@ int UtcDaliActorSetKeyboardFocusable(void)
 
   Actor actor = Actor::New();
 
-  actor.SetKeyboardFocusable(true);
-  DALI_TEST_CHECK(actor.IsKeyboardFocusable() == true);
+  actor.SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, true );
+  DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ) == true);
 
-  actor.SetKeyboardFocusable(false);
-  DALI_TEST_CHECK(actor.IsKeyboardFocusable() == false);
+  actor.SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, false );
+  DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ) == false);
   END_TEST;
 }
 
@@ -2345,7 +2512,7 @@ int UtcDaliActorIsKeyboardFocusable(void)
 
   Actor actor = Actor::New();
 
-  DALI_TEST_CHECK(actor.IsKeyboardFocusable() == false);
+  DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ) == false);
   END_TEST;
 }
 
@@ -2364,7 +2531,7 @@ int UtcDaliActorRemoveConstraints(void)
 
   DALI_TEST_CHECK( gTestConstraintCalled == false );
 
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
   constraint.Apply();
 
   // flush the queue and render once
@@ -2398,7 +2565,7 @@ int UtcDaliActorRemoveConstraintTag(void)
   constraint2.SetTag( constraint2Tag );
   constraint2.Apply();
 
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
@@ -2411,7 +2578,7 @@ int UtcDaliActorRemoveConstraintTag(void)
   result2 = 0;
   actor.RemoveConstraints(constraint1Tag);
   // make color property dirty, which will trigger constraints to be reapplied.
-  actor.SetColor( Color::WHITE );
+  actor.SetProperty( Actor::Property::COLOR, Color::WHITE );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
@@ -2424,7 +2591,7 @@ int UtcDaliActorRemoveConstraintTag(void)
   result2 = 0;
   constraint1.Apply();
   // make color property dirty, which will trigger constraints to be reapplied.
-  actor.SetColor( Color::WHITE );
+  actor.SetProperty( Actor::Property::COLOR, Color::WHITE );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
@@ -2437,7 +2604,7 @@ int UtcDaliActorRemoveConstraintTag(void)
   result2 = 0;
   actor.RemoveConstraints(constraint2Tag);
   // make color property dirty, which will trigger constraints to be reapplied.
-  actor.SetColor( Color::WHITE );
+  actor.SetProperty( Actor::Property::COLOR, Color::WHITE );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
@@ -2450,7 +2617,7 @@ int UtcDaliActorRemoveConstraintTag(void)
   result2 = 0;
   actor.RemoveConstraints(constraint1Tag);
   // make color property dirty, which will trigger constraints to be reapplied.
-  actor.SetColor( Color::WHITE );
+  actor.SetProperty( Actor::Property::COLOR, Color::WHITE );
   // flush the queue and render once
   application.SendNotification();
   application.Render();
@@ -2467,17 +2634,17 @@ int UtcDaliActorTouchedSignal(void)
   ResetTouchCallbacks();
 
   // get the root layer
-  Actor actor = Stage::GetCurrent().GetRootLayer();
+  Actor actor = application.GetScene().GetRootLayer();
   DALI_TEST_CHECK( gTouchCallBackCalled == false );
 
   application.SendNotification();
   application.Render();
 
   // connect to its touch signal
-  actor.TouchedSignal().Connect( TestCallback );
+  actor.TouchedSignal().Connect( TestTouchCallback );
 
   // simulate a touch event in the middle of the screen
-  Vector2 touchPoint( Stage::GetCurrent().GetSize() * 0.5 );
+  Vector2 touchPoint( application.GetScene().GetSize() * 0.5 );
   Dali::Integration::Point point;
   point.SetDeviceId( 1 );
   point.SetState( PointState::DOWN );
@@ -2497,7 +2664,7 @@ int UtcDaliActorHoveredSignal(void)
   gHoverCallBackCalled = false;
 
   // get the root layer
-  Actor actor = Stage::GetCurrent().GetRootLayer();
+  Actor actor = application.GetScene().GetRootLayer();
   DALI_TEST_CHECK( gHoverCallBackCalled == false );
 
   application.SendNotification();
@@ -2507,7 +2674,7 @@ int UtcDaliActorHoveredSignal(void)
   actor.HoveredSignal().Connect( TestCallback3 );
 
   // simulate a hover event in the middle of the screen
-  Vector2 touchPoint( Stage::GetCurrent().GetSize() * 0.5 );
+  Vector2 touchPoint( application.GetScene().GetSize() * 0.5 );
   Dali::Integration::Point point;
   point.SetDeviceId( 1 );
   point.SetState( PointState::MOTION );
@@ -2520,91 +2687,91 @@ int UtcDaliActorHoveredSignal(void)
   END_TEST;
 }
 
-int UtcDaliActorOnOffStageSignal(void)
+int UtcDaliActorOnOffSceneSignal(void)
 {
-  tet_infoline("Testing Dali::Actor::OnStageSignal() and OffStageSignal()");
+  tet_infoline("Testing Dali::Actor::OnSceneSignal() and OffSceneSignal()");
 
   TestApplication application;
 
   // clean test data
-  gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
-  gActorNamesOnOffStage.clear();
+  gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
+  gActorNamesOnOffScene.clear();
 
   Actor parent = Actor::New();
-  parent.SetName( "parent" );
-  parent.OnStageSignal().Connect( OnStageCallback );
-  parent.OffStageSignal().Connect( OffStageCallback );
+  parent.SetProperty( Actor::Property::NAME, "parent" );
+  parent.OnSceneSignal().Connect( OnSceneCallback );
+  parent.OffSceneSignal().Connect( OffSceneCallback );
   // sanity check
-  DALI_TEST_CHECK( gOnStageCallBackCalled == 0 );
-  DALI_TEST_CHECK( gOffStageCallBackCalled == 0 );
+  DALI_TEST_CHECK( gOnSceneCallBackCalled == 0 );
+  DALI_TEST_CHECK( gOffSceneCallBackCalled == 0 );
 
-  // add parent to stage
-  Stage::GetCurrent().Add( parent );
+  // add parent to the scene
+  application.GetScene().Add( parent );
   // onstage emitted, offstage not
-  DALI_TEST_EQUALS(  gOnStageCallBackCalled, 1, TEST_LOCATION );
-  DALI_TEST_EQUALS( gOffStageCallBackCalled, 0, TEST_LOCATION );
-  DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
+  DALI_TEST_EQUALS(  gOnSceneCallBackCalled, 1, TEST_LOCATION );
+  DALI_TEST_EQUALS( gOffSceneCallBackCalled, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( "parent", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
 
   // test adding a child, should get onstage emitted
   // clean test data
-  gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
-  gActorNamesOnOffStage.clear();
+  gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
+  gActorNamesOnOffScene.clear();
 
   Actor child = Actor::New();
-  child.SetName( "child" );
-  child.OnStageSignal().Connect( OnStageCallback );
-  child.OffStageSignal().Connect( OffStageCallback );
+  child.SetProperty( Actor::Property::NAME, "child" );
+  child.OnSceneSignal().Connect( OnSceneCallback );
+  child.OffSceneSignal().Connect( OffSceneCallback );
   parent.Add( child ); // add child
-  // onstage emitted, offstage not
-  DALI_TEST_EQUALS(  gOnStageCallBackCalled, 1, TEST_LOCATION );
-  DALI_TEST_EQUALS( gOffStageCallBackCalled, 0, TEST_LOCATION );
-  DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
+  // onscene emitted, offscene not
+  DALI_TEST_EQUALS(  gOnSceneCallBackCalled, 1, TEST_LOCATION );
+  DALI_TEST_EQUALS( gOffSceneCallBackCalled, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( "child", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
 
-  // test removing parent from stage
+  // test removing parent from the scene
   // clean test data
-  gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
-  gActorNamesOnOffStage.clear();
+  gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
+  gActorNamesOnOffScene.clear();
 
-  Stage::GetCurrent().Remove( parent );
-  // onstage not emitted, offstage is
-  DALI_TEST_EQUALS(  gOnStageCallBackCalled, 0, TEST_LOCATION );
-  DALI_TEST_EQUALS( gOffStageCallBackCalled, 2, TEST_LOCATION );
-  DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
-  DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 1 ], TEST_LOCATION );
+  application.GetScene().Remove( parent );
+  // onscene not emitted, offscene is
+  DALI_TEST_EQUALS(  gOnSceneCallBackCalled, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( gOffSceneCallBackCalled, 2, TEST_LOCATION );
+  DALI_TEST_EQUALS( "child", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
+  DALI_TEST_EQUALS( "parent", gActorNamesOnOffScene[ 1 ], TEST_LOCATION );
 
-  // test adding parent back to stage
+  // test adding parent back to the scene
   // clean test data
-  gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
-  gActorNamesOnOffStage.clear();
+  gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
+  gActorNamesOnOffScene.clear();
 
-  Stage::GetCurrent().Add( parent );
-  // onstage emitted, offstage not
-  DALI_TEST_EQUALS(  gOnStageCallBackCalled, 2, TEST_LOCATION );
-  DALI_TEST_EQUALS( gOffStageCallBackCalled, 0, TEST_LOCATION );
-  DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
-  DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 1 ], TEST_LOCATION );
+  application.GetScene().Add( parent );
+  // onscene emitted, offscene not
+  DALI_TEST_EQUALS(  gOnSceneCallBackCalled, 2, TEST_LOCATION );
+  DALI_TEST_EQUALS( gOffSceneCallBackCalled, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( "parent", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
+  DALI_TEST_EQUALS( "child", gActorNamesOnOffScene[ 1 ], TEST_LOCATION );
 
   // test removing child
   // clean test data
-  gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
-  gActorNamesOnOffStage.clear();
+  gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
+  gActorNamesOnOffScene.clear();
 
   parent.Remove( child );
-  // onstage not emitted, offstage is
-  DALI_TEST_EQUALS(  gOnStageCallBackCalled, 0, TEST_LOCATION );
-  DALI_TEST_EQUALS( gOffStageCallBackCalled, 1, TEST_LOCATION );
-  DALI_TEST_EQUALS( "child", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
+  // onscene not emitted, offscene is
+  DALI_TEST_EQUALS(  gOnSceneCallBackCalled, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( gOffSceneCallBackCalled, 1, TEST_LOCATION );
+  DALI_TEST_EQUALS( "child", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
 
   // test removing parent
   // clean test data
-  gOnStageCallBackCalled = gOffStageCallBackCalled = 0;
-  gActorNamesOnOffStage.clear();
+  gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
+  gActorNamesOnOffScene.clear();
 
-  Stage::GetCurrent().Remove( parent );
-  // onstage not emitted, offstage is
-  DALI_TEST_EQUALS(  gOnStageCallBackCalled, 0, TEST_LOCATION );
-  DALI_TEST_EQUALS( gOffStageCallBackCalled, 1, TEST_LOCATION );
-  DALI_TEST_EQUALS( "parent", gActorNamesOnOffStage[ 0 ], TEST_LOCATION );
+  application.GetScene().Remove( parent );
+  // onscene not emitted, offscene is
+  DALI_TEST_EQUALS(  gOnSceneCallBackCalled, 0, TEST_LOCATION );
+  DALI_TEST_EQUALS( gOffSceneCallBackCalled, 1, TEST_LOCATION );
+  DALI_TEST_EQUALS( "parent", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
   END_TEST;
 }
 
@@ -2614,11 +2781,11 @@ int UtcDaliActorFindChildByName(void)
   TestApplication application;
 
   Actor parent = Actor::New();
-  parent.SetName( "parent" );
+  parent.SetProperty( Actor::Property::NAME, "parent" );
   Actor first  = Actor::New();
-  first .SetName( "first" );
+  first .SetProperty( Actor::Property::NAME, "first" );
   Actor second = Actor::New();
-  second.SetName( "second" );
+  second.SetProperty( Actor::Property::NAME, "second" );
 
   parent.Add(first);
   first.Add(second);
@@ -2652,13 +2819,13 @@ int UtcDaliActorFindChildById(void)
   Actor found = parent.FindChildById( 100000 );
   DALI_TEST_CHECK( !found );
 
-  found = parent.FindChildById( parent.GetId() );
+  found = parent.FindChildById( parent.GetProperty< int >( Actor::Property::ID ) );
   DALI_TEST_CHECK( found == parent );
 
-  found = parent.FindChildById( first.GetId() );
+  found = parent.FindChildById( first.GetProperty< int >( Actor::Property::ID ) );
   DALI_TEST_CHECK( found == first );
 
-  found = parent.FindChildById( second.GetId() );
+  found = parent.FindChildById( second.GetProperty< int >( Actor::Property::ID ) );
   DALI_TEST_CHECK( found == second );
   END_TEST;
 }
@@ -2695,18 +2862,18 @@ int UtcDaliActorHitTest(void)
 
   // get the root layer
   Actor actor = Actor::New();
-  actor.SetAnchorPoint( AnchorPoint::CENTER );
-  actor.SetParentOrigin( ParentOrigin::CENTER );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
 
   ResetTouchCallbacks();
 
   unsigned int index = 0;
   while( NULL != hitTestData[index] )
   {
-    actor.SetSize( 1.f, 1.f );
-    actor.SetScale( hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z );
+    actor.SetProperty( Actor::Property::SIZE, Vector2( 1.f, 1.f ) );
+    actor.SetProperty( Actor::Property::SCALE, Vector3( hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z ) );
 
     // flush the queue and render once
     application.SendNotification();
@@ -2715,7 +2882,7 @@ int UtcDaliActorHitTest(void)
     DALI_TEST_CHECK( !gTouchCallBackCalled );
 
     // connect to its touch signal
-    actor.TouchedSignal().Connect(TestCallback);
+    actor.TouchedSignal().Connect(TestTouchCallback);
 
     Dali::Integration::Point point;
     point.SetState( PointState::DOWN );
@@ -2744,73 +2911,73 @@ int UtcDaliActorHitTest(void)
 
 int UtcDaliActorSetDrawMode(void)
 {
-  TestApplication app;
+  TestApplication application;
   tet_infoline(" UtcDaliActorSetDrawModeOverlay");
 
   Actor a = Actor::New();
 
-  Stage::GetCurrent().Add(a);
-  app.SendNotification();
-  app.Render(0);
-  app.SendNotification();
-  app.Render(1);
+  application.GetScene().Add(a);
+  application.SendNotification();
+  application.Render(0);
+  application.SendNotification();
+  application.Render(1);
 
-  DALI_TEST_CHECK( DrawMode::NORMAL == a.GetDrawMode() ); // Ensure overlay is off by default
+  DALI_TEST_CHECK( DrawMode::NORMAL == a.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ) ); // Ensure overlay is off by default
 
-  a.SetDrawMode( DrawMode::OVERLAY_2D );
-  app.SendNotification();
-  app.Render(1);
+  a.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
+  application.SendNotification();
+  application.Render(1);
 
-  DALI_TEST_CHECK( DrawMode::OVERLAY_2D == a.GetDrawMode() ); // Check Actor is overlay
+  DALI_TEST_CHECK( DrawMode::OVERLAY_2D == a.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ) ); // Check Actor is overlay
 
-  a.SetDrawMode( DrawMode::NORMAL );
-  app.SendNotification();
-  app.Render(1);
+  a.SetProperty( Actor::Property::DRAW_MODE, DrawMode::NORMAL );
+  application.SendNotification();
+  application.Render(1);
 
-  DALI_TEST_CHECK( DrawMode::NORMAL == a.GetDrawMode() ); // Check Actor is normal
+  DALI_TEST_CHECK( DrawMode::NORMAL == a.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ) ); // Check Actor is normal
   END_TEST;
 }
 
 int UtcDaliActorSetDrawModeOverlayRender(void)
 {
-  TestApplication app;
+  TestApplication application;
   tet_infoline(" UtcDaliActorSetDrawModeOverlayRender");
 
-  app.SendNotification();
-  app.Render(1);
+  application.SendNotification();
+  application.Render(1);
 
   std::vector<GLuint> ids;
   ids.push_back( 8 );   // first rendered actor
   ids.push_back( 9 );   // second rendered actor
   ids.push_back( 10 );  // third rendered actor
-  app.GetGlAbstraction().SetNextTextureIds( ids );
+  application.GetGlAbstraction().SetNextTextureIds( ids );
 
-  BufferImage imageA = BufferImage::New(16, 16);
-  BufferImage imageB = BufferImage::New(16, 16);
-  BufferImage imageC = BufferImage::New(16, 16);
+  Texture imageA = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 16, 16);
+  Texture imageB = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 16, 16);
+  Texture imageC = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 16, 16);
   Actor a = CreateRenderableActor( imageA );
   Actor b = CreateRenderableActor( imageB );
   Actor c = CreateRenderableActor( imageC );
 
-  app.SendNotification();
-  app.Render(1);
+  application.SendNotification();
+  application.Render(1);
 
   //Textures are bound when first created. Clear bound textures vector
-  app.GetGlAbstraction().ClearBoundTextures();
+  application.GetGlAbstraction().ClearBoundTextures();
 
   // Render a,b,c as regular non-overlays. so order will be:
   // a (8)
   // b (9)
   // c (10)
-  Stage::GetCurrent().Add(a);
-  Stage::GetCurrent().Add(b);
-  Stage::GetCurrent().Add(c);
+  application.GetScene().Add(a);
+  application.GetScene().Add(b);
+  application.GetScene().Add(c);
 
-  app.SendNotification();
-  app.Render(1);
+  application.SendNotification();
+  application.Render(1);
 
   // Should be 3 textures changes.
-  const std::vector<GLuint>& boundTextures = app.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
+  const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
   typedef std::vector<GLuint>::size_type TextureSize;
   DALI_TEST_EQUALS( boundTextures.size(), static_cast<TextureSize>( 3 ), TEST_LOCATION );
   if( boundTextures.size() == 3 )
@@ -2825,11 +2992,11 @@ int UtcDaliActorSetDrawModeOverlayRender(void)
   // b (9)
   // c (10)
   // a (8)
-  a.SetDrawMode( DrawMode::OVERLAY_2D );
-  app.GetGlAbstraction().ClearBoundTextures();
+  a.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
+  application.GetGlAbstraction().ClearBoundTextures();
 
-  app.SendNotification();
-  app.Render(1);
+  application.SendNotification();
+  application.Render(1);
 
   // Should be 3 texture changes.
   DALI_TEST_EQUALS( boundTextures.size(), static_cast<TextureSize>(3), TEST_LOCATION );
@@ -2844,36 +3011,36 @@ int UtcDaliActorSetDrawModeOverlayRender(void)
 
 int UtcDaliActorGetCurrentWorldMatrix(void)
 {
-  TestApplication app;
+  TestApplication application;
   tet_infoline(" UtcDaliActorGetCurrentWorldMatrix");
 
   Actor parent = Actor::New();
-  parent.SetParentOrigin(ParentOrigin::CENTER);
-  parent.SetAnchorPoint(AnchorPoint::CENTER);
+  parent.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
+  parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
   Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
   Radian rotationAngle(Degree(85.0f));
   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
-  parent.SetPosition( parentPosition );
-  parent.SetOrientation( parentRotation );
-  parent.SetScale( parentScale );
-  Stage::GetCurrent().Add( parent );
+  parent.SetProperty( Actor::Property::POSITION, parentPosition );
+  parent.SetProperty( Actor::Property::ORIENTATION, parentRotation );
+  parent.SetProperty( Actor::Property::SCALE, parentScale );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
-  child.SetParentOrigin(ParentOrigin::CENTER);
+  child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
   Vector3 childPosition( 0.0f, 0.0f, 100.0f );
   Radian childRotationAngle(Degree(23.0f));
   Quaternion childRotation( childRotationAngle, Vector3::YAXIS );
   Vector3 childScale( 2.0f, 2.0f, 2.0f );
-  child.SetPosition( childPosition );
-  child.SetOrientation( childRotation );
-  child.SetScale( childScale );
+  child.SetProperty( Actor::Property::POSITION, childPosition );
+  child.SetProperty( Actor::Property::ORIENTATION, childRotation );
+  child.SetProperty( Actor::Property::SCALE, childScale );
   parent.Add( child );
 
-  app.SendNotification();
-  app.Render(0);
-  app.Render();
-  app.SendNotification();
+  application.SendNotification();
+  application.Render(0);
+  application.Render();
+  application.SendNotification();
 
   Matrix parentMatrix(false);
   parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
@@ -2885,8 +3052,8 @@ int UtcDaliActorGetCurrentWorldMatrix(void)
   Matrix childWorldMatrix(false);
   Matrix::Multiply( childWorldMatrix, childMatrix, parentMatrix);
 
-  DALI_TEST_EQUALS( parent.GetCurrentWorldMatrix(), parentMatrix, 0.001, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentWorldMatrix(), childWorldMatrix, 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX ), parentMatrix, 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX ), childWorldMatrix, 0.001, TEST_LOCATION );
   END_TEST;
 }
 
@@ -2894,118 +3061,118 @@ int UtcDaliActorGetCurrentWorldMatrix(void)
 
 int UtcDaliActorConstrainedToWorldMatrix(void)
 {
-  TestApplication app;
+  TestApplication application;
   tet_infoline(" UtcDaliActorConstrainedToWorldMatrix");
 
   Actor parent = Actor::New();
-  parent.SetParentOrigin(ParentOrigin::CENTER);
-  parent.SetAnchorPoint(AnchorPoint::CENTER);
+  parent.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
+  parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
   Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
   Radian rotationAngle(Degree(85.0f));
   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
-  parent.SetPosition( parentPosition );
-  parent.SetOrientation( parentRotation );
-  parent.SetScale( parentScale );
-  Stage::GetCurrent().Add( parent );
+  parent.SetProperty( Actor::Property::POSITION, parentPosition );
+  parent.SetProperty( Actor::Property::ORIENTATION, parentRotation );
+  parent.SetProperty( Actor::Property::SCALE, parentScale );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
-  child.SetParentOrigin(ParentOrigin::CENTER);
+  child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
   Constraint posConstraint = Constraint::New<Vector3>( child, Actor::Property::POSITION, PositionComponentConstraint() );
   posConstraint.AddSource( Source( parent, Actor::Property::WORLD_MATRIX ) );
   posConstraint.Apply();
 
-  Stage::GetCurrent().Add( child );
+  application.GetScene().Add( child );
 
-  app.SendNotification();
-  app.Render(0);
-  app.Render();
-  app.SendNotification();
+  application.SendNotification();
+  application.Render(0);
+  application.Render();
+  application.SendNotification();
 
   Matrix parentMatrix(false);
   parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
 
-  DALI_TEST_EQUALS( parent.GetCurrentWorldMatrix(), parentMatrix, 0.001, TEST_LOCATION );
-  DALI_TEST_EQUALS( child.GetCurrentPosition(), parent.GetCurrentPosition(), 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( parent.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX ), parentMatrix, 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), parent.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), 0.001, TEST_LOCATION );
   END_TEST;
 }
 
 int UtcDaliActorConstrainedToOrientation(void)
 {
-  TestApplication app;
+  TestApplication application;
   tet_infoline(" UtcDaliActorConstrainedToOrientation");
 
   Actor parent = Actor::New();
-  parent.SetParentOrigin(ParentOrigin::CENTER);
-  parent.SetAnchorPoint(AnchorPoint::CENTER);
+  parent.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
+  parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
   Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
   Radian rotationAngle(Degree(85.0f));
   Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
   Vector3 parentScale( 1.0f, 2.0f, 3.0f );
-  parent.SetPosition( parentPosition );
-  parent.SetOrientation( parentRotation );
-  parent.SetScale( parentScale );
-  Stage::GetCurrent().Add( parent );
+  parent.SetProperty( Actor::Property::POSITION, parentPosition );
+  parent.SetProperty( Actor::Property::ORIENTATION, parentRotation );
+  parent.SetProperty( Actor::Property::SCALE, parentScale );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
-  child.SetParentOrigin(ParentOrigin::CENTER);
+  child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
   Constraint posConstraint = Constraint::New<Quaternion>( child, Actor::Property::ORIENTATION, OrientationComponentConstraint() );
   posConstraint.AddSource( Source( parent, Actor::Property::ORIENTATION ) );
   posConstraint.Apply();
 
-  Stage::GetCurrent().Add( child );
+  application.GetScene().Add( child );
 
-  app.SendNotification();
-  app.Render(0);
-  app.Render();
-  app.SendNotification();
+  application.SendNotification();
+  application.Render(0);
+  application.Render();
+  application.SendNotification();
 
-  DALI_TEST_EQUALS( child.GetCurrentOrientation(), parent.GetCurrentOrientation(), 0.001, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), parent.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION );
   END_TEST;
 }
 
 int UtcDaliActorConstrainedToOpacity(void)
 {
-  TestApplication app;
+  TestApplication application;
   tet_infoline(" UtcDaliActorConstrainedToOpacity");
 
   Actor parent = Actor::New();
-  parent.SetOpacity( 0.7f );
-  Stage::GetCurrent().Add( parent );
+  parent.SetProperty( Actor::Property::OPACITY, 0.7f );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
-  Constraint opacityConstraint = Constraint::New<float>( child, DevelActor::Property::OPACITY, EqualToConstraint() );
-  opacityConstraint.AddSource( Source( parent, DevelActor::Property::OPACITY ) );
+  Constraint opacityConstraint = Constraint::New<float>( child, Actor::Property::OPACITY, EqualToConstraint() );
+  opacityConstraint.AddSource( Source( parent, Actor::Property::OPACITY ) );
   opacityConstraint.Apply();
 
-  Stage::GetCurrent().Add( child );
+  application.GetScene().Add( child );
 
-  app.SendNotification();
-  app.Render(0);
-  app.Render();
-  app.SendNotification();
+  application.SendNotification();
+  application.Render(0);
+  application.Render();
+  application.SendNotification();
 
-  DALI_TEST_EQUALS( child.GetCurrentOpacity(), parent.GetCurrentOpacity(), 0.001f, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< float >( Actor::Property::OPACITY ), parent.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.001f, TEST_LOCATION );
 
-  parent.SetOpacity( 0.3f );
+  parent.SetProperty( Actor::Property::OPACITY, 0.3f );
 
-  app.SendNotification();
-  app.Render(0);
-  app.Render();
-  app.SendNotification();
+  application.SendNotification();
+  application.Render(0);
+  application.Render();
+  application.SendNotification();
 
-  DALI_TEST_EQUALS( child.GetCurrentOpacity(), parent.GetCurrentOpacity(), 0.001f, TEST_LOCATION );
+  DALI_TEST_EQUALS( child.GetCurrentProperty< float >( Actor::Property::OPACITY ), parent.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.001f, TEST_LOCATION );
 
   END_TEST;
 }
 
 int UtcDaliActorUnparent(void)
 {
-  TestApplication app;
+  TestApplication application;
   tet_infoline(" UtcDaliActorUnparent");
 
   Actor parent = Actor::New();
-  Stage::GetCurrent().Add( parent );
+  application.GetScene().Add( parent );
 
   Actor child = Actor::New();
 
@@ -3049,11 +3216,11 @@ int UtcDaliActorUnparent(void)
 
 int UtcDaliActorGetChildAt(void)
 {
-  TestApplication app;
+  TestApplication application;
   tet_infoline(" UtcDaliActorGetChildAt");
 
   Actor parent = Actor::New();
-  Stage::GetCurrent().Add( parent );
+  application.GetScene().Add( parent );
 
   Actor child0 = Actor::New();
   parent.Add( child0 );
@@ -3072,12 +3239,12 @@ int UtcDaliActorGetChildAt(void)
 
 int UtcDaliActorSetGetOverlay(void)
 {
-  TestApplication app;
+  TestApplication application;
   tet_infoline(" UtcDaliActorSetGetOverlay");
 
   Actor parent = Actor::New();
-  parent.SetDrawMode(DrawMode::OVERLAY_2D );
-  DALI_TEST_CHECK( parent.GetDrawMode() == DrawMode::OVERLAY_2D );
+  parent.SetProperty( Actor::Property::DRAW_MODE,DrawMode::OVERLAY_2D );
+  DALI_TEST_CHECK( parent.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ) == DrawMode::OVERLAY_2D );
   END_TEST;
 }
 
@@ -3141,13 +3308,12 @@ const PropertyStringIndex PROPERTY_TABLE[] =
   { "leaveRequired",            Actor::Property::LEAVE_REQUIRED,           Property::BOOLEAN     },
   { "inheritOrientation",       Actor::Property::INHERIT_ORIENTATION,      Property::BOOLEAN     },
   { "inheritScale",             Actor::Property::INHERIT_SCALE,            Property::BOOLEAN     },
-  { "colorMode",                Actor::Property::COLOR_MODE,               Property::STRING      },
-  { "positionInheritance",      Actor::Property::POSITION_INHERITANCE,     Property::STRING      },
-  { "drawMode",                 Actor::Property::DRAW_MODE,                Property::STRING      },
+  { "colorMode",                Actor::Property::COLOR_MODE,               Property::INTEGER     },
+  { "drawMode",                 Actor::Property::DRAW_MODE,                Property::INTEGER     },
   { "sizeModeFactor",           Actor::Property::SIZE_MODE_FACTOR,         Property::VECTOR3     },
   { "widthResizePolicy",        Actor::Property::WIDTH_RESIZE_POLICY,      Property::STRING      },
   { "heightResizePolicy",       Actor::Property::HEIGHT_RESIZE_POLICY,     Property::STRING      },
-  { "sizeScalePolicy",          Actor::Property::SIZE_SCALE_POLICY,        Property::STRING      },
+  { "sizeScalePolicy",          Actor::Property::SIZE_SCALE_POLICY,        Property::INTEGER     },
   { "widthForHeight",           Actor::Property::WIDTH_FOR_HEIGHT,         Property::BOOLEAN     },
   { "heightForWidth",           Actor::Property::HEIGHT_FOR_WIDTH,         Property::BOOLEAN     },
   { "padding",                  Actor::Property::PADDING,                  Property::VECTOR4     },
@@ -3155,14 +3321,14 @@ const PropertyStringIndex PROPERTY_TABLE[] =
   { "maximumSize",              Actor::Property::MAXIMUM_SIZE,             Property::VECTOR2     },
   { "inheritPosition",          Actor::Property::INHERIT_POSITION,         Property::BOOLEAN     },
   { "clippingMode",             Actor::Property::CLIPPING_MODE,            Property::STRING      },
-  { "opacity",                  DevelActor::Property::OPACITY,             Property::FLOAT       },
+  { "opacity",                  Actor::Property::OPACITY,             Property::FLOAT       },
 };
 const unsigned int PROPERTY_TABLE_COUNT = sizeof( PROPERTY_TABLE ) / sizeof( PROPERTY_TABLE[0] );
 } // unnamed namespace
 
 int UtcDaliActorProperties(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
@@ -3178,7 +3344,7 @@ int UtcDaliActorProperties(void)
 
 int UtcDaliRelayoutProperties_ResizePolicies(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
@@ -3218,44 +3384,43 @@ int UtcDaliRelayoutProperties_ResizePolicies(void)
 
 int UtcDaliRelayoutProperties_SizeScalePolicy(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
   // Defaults
-  DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), "USE_SIZE_SET", TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetSizeScalePolicy(), SizeScalePolicy::USE_SIZE_SET, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY ), SizeScalePolicy::USE_SIZE_SET, TEST_LOCATION );
 
   SizeScalePolicy::Type policy = SizeScalePolicy::FILL_WITH_ASPECT_RATIO;
-  actor.SetSizeScalePolicy( policy );
-  DALI_TEST_EQUALS( actor.GetSizeScalePolicy(), policy, TEST_LOCATION );
+  actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy );
+  DALI_TEST_EQUALS( actor.GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY ), policy, TEST_LOCATION );
 
   // Set
-  const char* const policy1 = "FIT_WITH_ASPECT_RATIO";
-  const char* const policy2 = "FILL_WITH_ASPECT_RATIO";
+  const SizeScalePolicy::Type policy1 = SizeScalePolicy::FIT_WITH_ASPECT_RATIO;
+  const SizeScalePolicy::Type policy2 = SizeScalePolicy::FILL_WITH_ASPECT_RATIO;
 
   actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy1 );
-  DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), policy1, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY ), policy1, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy2 );
-  DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_SCALE_POLICY ).Get< std::string >(), policy2, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY ), policy2, TEST_LOCATION );
 
   END_TEST;
 }
 
 int UtcDaliRelayoutProperties_SizeModeFactor(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
   // Defaults
   DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_MODE_FACTOR ).Get< Vector3 >(), Vector3( 1.0f, 1.0f, 1.0f ), TEST_LOCATION );
-  DALI_TEST_EQUALS( actor.GetSizeModeFactor(), Vector3( 1.0f, 1.0f, 1.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR ), Vector3( 1.0f, 1.0f, 1.0f ), TEST_LOCATION );
 
   Vector3 sizeMode( 1.0f, 2.0f, 3.0f );
-  actor.SetSizeModeFactor( sizeMode );
-  DALI_TEST_EQUALS( actor.GetSizeModeFactor(), sizeMode, TEST_LOCATION );
+  actor.SetProperty( Actor::Property::SIZE_MODE_FACTOR, sizeMode );
+  DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR ), sizeMode, TEST_LOCATION );
 
   // Set
   Vector3 sizeMode1( 2.0f, 3.0f, 4.0f );
@@ -3268,7 +3433,7 @@ int UtcDaliRelayoutProperties_SizeModeFactor(void)
 
 int UtcDaliRelayoutProperties_DimensionDependency(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
@@ -3292,7 +3457,7 @@ int UtcDaliRelayoutProperties_DimensionDependency(void)
 
 int UtcDaliRelayoutProperties_Padding(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
@@ -3310,7 +3475,7 @@ int UtcDaliRelayoutProperties_Padding(void)
 
 int UtcDaliRelayoutProperties_MinimumMaximumSize(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
@@ -3334,7 +3499,7 @@ int UtcDaliRelayoutProperties_MinimumMaximumSize(void)
 
 int UtcDaliActorGetHeightForWidth(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
@@ -3345,7 +3510,7 @@ int UtcDaliActorGetHeightForWidth(void)
 
 int UtcDaliActorGetWidthForHeight(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
@@ -3356,21 +3521,21 @@ int UtcDaliActorGetWidthForHeight(void)
 
 int UtcDaliActorGetRelayoutSize(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
   // Add actor to stage
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
 
   DALI_TEST_EQUALS( actor.GetRelayoutSize( Dimension::WIDTH ), 0.0f, TEST_LOCATION );
 
   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
-  actor.SetSize( Vector2( 1.0f, 0.0f ) );
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 0.0f ) );
 
   // Flush the queue and render once
-  app.SendNotification();
-  app.Render();
+  application.SendNotification();
+  application.Render();
 
   DALI_TEST_EQUALS( actor.GetRelayoutSize( Dimension::WIDTH ), 1.0f, TEST_LOCATION );
 
@@ -3379,12 +3544,12 @@ int UtcDaliActorGetRelayoutSize(void)
 
 int UtcDaliActorSetPadding(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
   Padding padding;
-  actor.GetPadding( padding );
+  padding = actor.GetProperty<Vector4>( Actor::Property::PADDING );
 
   DALI_TEST_EQUALS( padding.left, 0.0f, TEST_LOCATION );
   DALI_TEST_EQUALS( padding.right, 0.0f, TEST_LOCATION );
@@ -3392,9 +3557,9 @@ int UtcDaliActorSetPadding(void)
   DALI_TEST_EQUALS( padding.top, 0.0f, TEST_LOCATION );
 
   Padding padding2( 1.0f, 2.0f, 3.0f, 4.0f );
-  actor.SetPadding( padding2 );
+  actor.SetProperty( Actor::Property::PADDING, padding2 );
 
-  actor.GetPadding( padding );
+  padding = actor.GetProperty<Vector4>( Actor::Property::PADDING );
 
   DALI_TEST_EQUALS( padding.left, padding2.left, TEST_LOCATION );
   DALI_TEST_EQUALS( padding.right, padding2.right, TEST_LOCATION );
@@ -3406,19 +3571,19 @@ int UtcDaliActorSetPadding(void)
 
 int UtcDaliActorSetMinimumSize(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
-  Vector2 size = actor.GetMinimumSize();
+  Vector2 size = actor.GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
 
   DALI_TEST_EQUALS( size.width, 0.0f, TEST_LOCATION );
   DALI_TEST_EQUALS( size.height, 0.0f, TEST_LOCATION );
 
   Vector2 size2( 1.0f, 2.0f );
-  actor.SetMinimumSize( size2 );
+  actor.SetProperty( Actor::Property::MINIMUM_SIZE, size2 );
 
-  size = actor.GetMinimumSize();
+  size = actor.GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
 
   DALI_TEST_EQUALS( size.width, size2.width, TEST_LOCATION );
   DALI_TEST_EQUALS( size.height, size2.height, TEST_LOCATION );
@@ -3428,19 +3593,19 @@ int UtcDaliActorSetMinimumSize(void)
 
 int UtcDaliActorSetMaximumSize(void)
 {
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
-  Vector2 size = actor.GetMaximumSize();
+  Vector2 size = actor.GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
 
   DALI_TEST_EQUALS( size.width, FLT_MAX, TEST_LOCATION );
   DALI_TEST_EQUALS( size.height, FLT_MAX, TEST_LOCATION );
 
   Vector2 size2( 1.0f, 2.0f );
-  actor.SetMaximumSize( size2 );
+  actor.SetProperty( Actor::Property::MAXIMUM_SIZE, size2 );
 
-  size = actor.GetMaximumSize();
+  size = actor.GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
 
   DALI_TEST_EQUALS( size.width, size2.width, TEST_LOCATION );
   DALI_TEST_EQUALS( size.height, size2.height, TEST_LOCATION );
@@ -3459,17 +3624,17 @@ int UtcDaliActorOnRelayoutSignal(void)
   gActorNamesRelayout.clear();
 
   Actor actor = Actor::New();
-  actor.SetName( "actor" );
+  actor.SetProperty( Actor::Property::NAME, "actor" );
   actor.OnRelayoutSignal().Connect( OnRelayoutCallback );
 
   // Sanity check
   DALI_TEST_CHECK( ! gOnRelayoutCallBackCalled );
 
   // Add actor to stage
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
 
   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
-  actor.SetSize( Vector2( 1.0f, 2.0 ) );
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 2.0 ) );
 
   // Flush the queue and render once
   application.SendNotification();
@@ -3500,7 +3665,7 @@ int UtcDaliActorGetHierachyDepth(void)
    *
    * GetHierarchyDepth should return 1 for A, 2 for B and C, and 3 for D, E and F.
    */
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   Actor actorA = Actor::New();
   Actor actorB = Actor::New();
@@ -3510,15 +3675,15 @@ int UtcDaliActorGetHierachyDepth(void)
   Actor actorF = Actor::New();
 
   //Test that root actor has depth equal 0
-  DALI_TEST_EQUALS( 0, stage.GetRootLayer().GetHierarchyDepth(), TEST_LOCATION );
+  DALI_TEST_EQUALS( 0, stage.GetRootLayer().GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
 
   //Test actors return depth -1 when not connected to the tree
-  DALI_TEST_EQUALS( -1, actorA.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorB.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorC.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorD.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorE.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorF.GetHierarchyDepth(), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorA.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorB.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorC.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorD.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorE.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorF.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
 
   //Create the hierarchy
   stage.Add( actorA );
@@ -3529,29 +3694,29 @@ int UtcDaliActorGetHierachyDepth(void)
   actorC.Add( actorF );
 
   //Test actors return correct depth
-  DALI_TEST_EQUALS( 1, actorA.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( 2, actorB.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( 2, actorC.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( 3, actorD.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( 3, actorE.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( 3, actorF.GetHierarchyDepth(), TEST_LOCATION );
+  DALI_TEST_EQUALS( 1, actorA.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( 2, actorB.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( 2, actorC.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( 3, actorD.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( 3, actorE.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( 3, actorF.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
 
   //Removing actorB from the hierarchy. actorB, actorD and actorE should now have depth equal -1
   actorA.Remove( actorB );
 
-  DALI_TEST_EQUALS( -1, actorB.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorD.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorE.GetHierarchyDepth(), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorB.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorD.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorE.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
 
   //Removing actorA from the stage. All actors should have depth equal -1
   stage.Remove( actorA );
 
-  DALI_TEST_EQUALS( -1, actorA.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorB.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorC.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorD.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorE.GetHierarchyDepth(), TEST_LOCATION );
-  DALI_TEST_EQUALS( -1, actorF.GetHierarchyDepth(), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorA.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorB.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorC.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorD.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorE.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( -1, actorF.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
 
   END_TEST;
 }
@@ -3563,35 +3728,35 @@ int UtcDaliActorAnchorPointPropertyAsString(void)
   Actor actor = Actor::New();
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_LEFT" );
-  DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::TOP_LEFT, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_CENTER" );
-  DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::TOP_CENTER, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_RIGHT" );
-  DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER_LEFT" );
-  DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER" );
-  DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::CENTER, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER_RIGHT" );
-  DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_LEFT" );
-  DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_CENTER" );
-  DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_RIGHT" );
-  DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
 
   // Invalid should not change anything
   actor.SetProperty( Actor::Property::ANCHOR_POINT, "INVALID_ARG" );
-  DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
 
   END_TEST;
 }
@@ -3603,35 +3768,35 @@ int UtcDaliActorParentOriginPropertyAsString(void)
   Actor actor = Actor::New();
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_LEFT" );
-  DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::TOP_LEFT, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_CENTER" );
-  DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::TOP_CENTER, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_RIGHT" );
-  DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER_LEFT" );
-  DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER" );
-  DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::CENTER, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER_RIGHT" );
-  DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_LEFT" );
-  DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_CENTER" );
-  DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_RIGHT" );
-  DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
 
   // Invalid should not change anything
   actor.SetProperty( Actor::Property::PARENT_ORIGIN, "INVALID_ARG" );
-  DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
 
   END_TEST;
 }
@@ -3643,45 +3808,20 @@ int UtcDaliActorColorModePropertyAsString(void)
   Actor actor = Actor::New();
 
   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_COLOR" );
-  DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_COLOR, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_COLOR, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_PARENT_COLOR" );
-  DALI_TEST_EQUALS( actor.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_PARENT_COLOR, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_COLOR" );
-  DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_ALPHA" );
-  DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
 
   // Invalid should not change anything
   actor.SetProperty( Actor::Property::COLOR_MODE, "INVALID_ARG" );
-  DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliActorPositionInheritancePropertyAsString(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-
-  actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "INHERIT_PARENT_POSITION" );
-  DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), INHERIT_PARENT_POSITION, TEST_LOCATION );
-
-  actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "USE_PARENT_POSITION" );
-  DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION, TEST_LOCATION );
-
-  actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "USE_PARENT_POSITION_PLUS_LOCAL_POSITION" );
-  DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION_PLUS_LOCAL_POSITION, TEST_LOCATION );
-
-  actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "DONT_INHERIT_POSITION" );
-  DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
-
-  // Invalid should not change anything
-  actor.SetProperty( Actor::Property::POSITION_INHERITANCE, "INVALID_ARG" );
-  DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
 
   END_TEST;
 }
@@ -3693,17 +3833,14 @@ int UtcDaliActorDrawModePropertyAsString(void)
   Actor actor = Actor::New();
 
   actor.SetProperty( Actor::Property::DRAW_MODE, "NORMAL" );
-  DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::NORMAL, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::NORMAL, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::DRAW_MODE, "OVERLAY_2D" );
-  DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
-
-  actor.SetProperty( Actor::Property::DRAW_MODE, "STENCIL" );
-  DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::STENCIL, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::OVERLAY_2D, TEST_LOCATION );
 
   // Invalid should not change anything
   actor.SetProperty( Actor::Property::DRAW_MODE, "INVALID_ARG" );
-  DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::STENCIL, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::OVERLAY_2D, TEST_LOCATION );
 
   END_TEST;
 }
@@ -3715,37 +3852,16 @@ int UtcDaliActorColorModePropertyAsEnum(void)
   Actor actor = Actor::New();
 
   actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_COLOR );
-  DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_COLOR, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_COLOR, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::COLOR_MODE, USE_PARENT_COLOR );
-  DALI_TEST_EQUALS( actor.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_PARENT_COLOR, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR );
-  DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA );
-  DALI_TEST_EQUALS( actor.GetColorMode(), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
-
-  END_TEST;
-}
-
-int UtcDaliActorPositionInheritancePropertyAsEnum(void)
-{
-  TestApplication application;
-
-  Actor actor = Actor::New();
-
-  actor.SetProperty( Actor::Property::POSITION_INHERITANCE, INHERIT_PARENT_POSITION );
-  DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), INHERIT_PARENT_POSITION, TEST_LOCATION );
-
-  actor.SetProperty( Actor::Property::POSITION_INHERITANCE, USE_PARENT_POSITION );
-  DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION, TEST_LOCATION );
-
-  actor.SetProperty( Actor::Property::POSITION_INHERITANCE, USE_PARENT_POSITION_PLUS_LOCAL_POSITION );
-  DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), USE_PARENT_POSITION_PLUS_LOCAL_POSITION, TEST_LOCATION );
-
-  actor.SetProperty( Actor::Property::POSITION_INHERITANCE, DONT_INHERIT_POSITION );
-  DALI_TEST_EQUALS( actor.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
 
   END_TEST;
 }
@@ -3757,13 +3873,10 @@ int UtcDaliActorDrawModePropertyAsEnum(void)
   Actor actor = Actor::New();
 
   actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::NORMAL );
-  DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::NORMAL, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::NORMAL, TEST_LOCATION );
 
   actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
-  DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::OVERLAY_2D, TEST_LOCATION );
-
-  actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::STENCIL );
-  DALI_TEST_EQUALS( actor.GetDrawMode(), DrawMode::STENCIL, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::OVERLAY_2D, TEST_LOCATION );
 
   END_TEST;
 }
@@ -3788,7 +3901,7 @@ int UtcDaliActorAddRendererP(void)
   END_TEST;
 }
 
-int UtcDaliActorAddRendererN(void)
+int UtcDaliActorAddRendererN01(void)
 {
   tet_infoline("Testing Actor::AddRenderer");
   TestApplication application;
@@ -3818,32 +3931,70 @@ int UtcDaliActorAddRendererN(void)
   END_TEST;
 }
 
-int UtcDaliActorAddRendererOnStage(void)
+int UtcDaliActorAddRendererN02(void)
 {
-  tet_infoline("Testing Actor::AddRenderer");
-  TestApplication application;
+  tet_infoline( "UtcDaliActorAddRendererN02" );
 
-  Actor actor = Actor::New();
-  Stage::GetCurrent().Add(actor);
+  Actor actor;
+  Renderer renderer;
 
-  application.SendNotification();
-  application.Render(0);
+  {
+    TestApplication application;
 
-  Geometry geometry = CreateQuadGeometry();
-  Shader shader = CreateShader();
-  Renderer renderer = Renderer::New(geometry, shader);
+    Geometry geometry = CreateQuadGeometry();
+    Shader shader = CreateShader();
+    renderer = Renderer::New( geometry, shader );
 
-  application.SendNotification();
-  application.Render(0);
+    actor = Actor::New();
+  }
 
+  // try illegal AddRenderer
   try
   {
     actor.AddRenderer( renderer );
-    tet_result(TET_PASS);
+    tet_printf( "Assertion test failed - no Exception\n" );
+    tet_result( TET_FAIL );
   }
-  catch(...)
+  catch( Dali::DaliException& e )
   {
-    tet_result(TET_FAIL);
+    DALI_TEST_PRINT_ASSERT( e );
+    DALI_TEST_ASSERT( e, "EventThreadServices::IsCoreRunning()", TEST_LOCATION );
+  }
+  catch(...)
+  {
+    tet_printf( "Assertion test failed - wrong Exception\n" );
+    tet_result( TET_FAIL );
+  }
+
+  END_TEST;
+}
+
+int UtcDaliActorAddRendererOnScene(void)
+{
+  tet_infoline("Testing Actor::AddRenderer");
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  application.GetScene().Add(actor);
+
+  application.SendNotification();
+  application.Render(0);
+
+  Geometry geometry = CreateQuadGeometry();
+  Shader shader = CreateShader();
+  Renderer renderer = Renderer::New(geometry, shader);
+
+  application.SendNotification();
+  application.Render(0);
+
+  try
+  {
+    actor.AddRenderer( renderer );
+    tet_result(TET_PASS);
+  }
+  catch(...)
+  {
+    tet_result(TET_FAIL);
   }
 
   END_TEST;
@@ -3945,20 +4096,25 @@ int UtcDaliActorRemoveRendererN(void)
 }
 
 // Clipping test helper functions:
-Actor CreateActorWithContent()
+Actor CreateActorWithContent( uint32_t width, uint32_t height)
 {
-  BufferImage image = BufferImage::New( 16u, 16u );
+  Texture image = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
   Actor actor = CreateRenderableActor( image );
 
   // Setup dimensions and position so actor is not skipped by culling.
   actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
-  actor.SetSize( 16.0f, 16.0f );
-  actor.SetParentOrigin( ParentOrigin::CENTER );
-  actor.SetAnchorPoint( AnchorPoint::CENTER );
+  actor.SetProperty( Actor::Property::SIZE, Vector2( width, height ) );
+  actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
 
   return actor;
 }
 
+Actor CreateActorWithContent16x16()
+{
+  return CreateActorWithContent( 16, 16 );
+}
+
 void GenerateTrace( TestApplication& application, TraceCallStack& enabledDisableTrace, TraceCallStack& stencilTrace )
 {
   enabledDisableTrace.Reset();
@@ -3986,7 +4142,7 @@ void CheckColorMask( TestGlAbstraction& glAbstraction, bool maskValue )
 int UtcDaliActorPropertyClippingP(void)
 {
   // This test checks the clippingMode property.
-  tet_infoline( "Testing Actor::Property::CLIPPING_MODE P" );
+  tet_infoline( "Testing Actor::Property::ClippingMode: P" );
   TestApplication application;
 
   Actor actor = Actor::New();
@@ -4003,7 +4159,7 @@ int UtcDaliActorPropertyClippingP(void)
     DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
   }
 
-  // Check setting the property.
+  // Check setting the property to the stencil mode.
   actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
 
   // Check the new value was set.
@@ -4016,13 +4172,25 @@ int UtcDaliActorPropertyClippingP(void)
     DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_CHILDREN, TEST_LOCATION );
   }
 
+  // Check setting the property to the scissor mode.
+  actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+  // Check the new value was set.
+  getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
+  getValueResult = getValue.Get( value );
+  DALI_TEST_CHECK( getValueResult );
+
+  if( getValueResult )
+  {
+    DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_TO_BOUNDING_BOX, TEST_LOCATION );
+  }
   END_TEST;
 }
 
 int UtcDaliActorPropertyClippingN(void)
 {
   // Negative test case for Clipping.
-  tet_infoline( "Testing Actor::Property::CLIPPING_MODE N" );
+  tet_infoline( "Testing Actor::Property::ClippingMode: N" );
   TestApplication application;
 
   Actor actor = Actor::New();
@@ -4057,7 +4225,7 @@ int UtcDaliActorPropertyClippingN(void)
 int UtcDaliActorPropertyClippingActor(void)
 {
   // This test checks that an actor is correctly setup for clipping.
-  tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor" );
+  tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor" );
   TestApplication application;
 
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
@@ -4066,9 +4234,9 @@ int UtcDaliActorPropertyClippingActor(void)
   size_t startIndex = 0u;
 
   // Create a clipping actor.
-  Actor actorDepth1Clip = CreateActorWithContent();
+  Actor actorDepth1Clip = CreateActorWithContent16x16();
   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
-  Stage::GetCurrent().Add( actorDepth1Clip );
+  application.GetScene().Add( actorDepth1Clip );
 
   // Gather the call trace.
   GenerateTrace( application, enabledDisableTrace, stencilTrace );
@@ -4093,7 +4261,7 @@ int UtcDaliActorPropertyClippingActor(void)
 int UtcDaliActorPropertyClippingActorEnableThenDisable(void)
 {
   // This test checks that an actor is correctly setup for clipping and then correctly setup when clipping is disabled
-  tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor enable and then disable" );
+  tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor enable and then disable" );
   TestApplication application;
 
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
@@ -4102,9 +4270,9 @@ int UtcDaliActorPropertyClippingActorEnableThenDisable(void)
   size_t startIndex = 0u;
 
   // Create a clipping actor.
-  Actor actorDepth1Clip = CreateActorWithContent();
+  Actor actorDepth1Clip = CreateActorWithContent16x16();
   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
-  Stage::GetCurrent().Add( actorDepth1Clip );
+  application.GetScene().Add( actorDepth1Clip );
 
   // Gather the call trace.
   GenerateTrace( application, enabledDisableTrace, stencilTrace );
@@ -4139,36 +4307,35 @@ int UtcDaliActorPropertyClippingActorEnableThenDisable(void)
   END_TEST;
 }
 
-
 int UtcDaliActorPropertyClippingNestedChildren(void)
 {
   // This test checks that a hierarchy of actors are clipped correctly by
   // writing to and reading from the correct bit-planes of the stencil buffer.
-  tet_infoline( "Testing Actor::Property::CLIPPING_MODE nested children" );
+  tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN nested children" );
   TestApplication application;
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
 
   // Create a clipping actor.
-  Actor actorDepth1Clip = CreateActorWithContent();
+  Actor actorDepth1Clip = CreateActorWithContent16x16();
   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
-  Stage::GetCurrent().Add( actorDepth1Clip );
+  application.GetScene().Add( actorDepth1Clip );
 
   // Create a child actor.
-  Actor childDepth2 = CreateActorWithContent();
+  Actor childDepth2 = CreateActorWithContent16x16();
   actorDepth1Clip.Add( childDepth2 );
 
   // Create another clipping actor.
-  Actor childDepth2Clip = CreateActorWithContent();
+  Actor childDepth2Clip = CreateActorWithContent16x16();
   childDepth2Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
   childDepth2.Add( childDepth2Clip );
 
   // Create another 2 child actors. We do this so 2 nodes will have the same clipping ID.
   // This tests the sort algorithm.
-  Actor childDepth3 = CreateActorWithContent();
+  Actor childDepth3 = CreateActorWithContent16x16();
   childDepth2Clip.Add( childDepth3 );
-  Actor childDepth4 = CreateActorWithContent();
+  Actor childDepth4 = CreateActorWithContent16x16();
   childDepth3.Add( childDepth4 );
 
   // Gather the call trace.
@@ -4210,7 +4377,7 @@ int UtcDaliActorPropertyClippingNestedChildren(void)
     // If we are on the first loop, set the layer to 3D and loop to perform the test again.
     if( i == 0u )
     {
-      Stage::GetCurrent().GetRootLayer().SetBehavior( Layer::LAYER_3D );
+      application.GetScene().GetRootLayer().SetProperty( Layer::Property::BEHAVIOR, Layer::LAYER_3D );
       GenerateTrace( application, enabledDisableTrace, stencilTrace );
     }
   }
@@ -4218,6 +4385,369 @@ int UtcDaliActorPropertyClippingNestedChildren(void)
   END_TEST;
 }
 
+int UtcDaliActorPropertyClippingActorDrawOrder(void)
+{
+  // This test checks that a hierarchy of actors are drawn in the correct order when clipping is enabled.
+  tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN draw order" );
+  TestApplication application;
+  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+  TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+  /* We create a small tree of actors as follows:
+
+                           A
+                          / \
+     Clipping enabled -> B   D
+                         |   |
+                         C   E
+
+     The correct draw order is "ABCDE" (the same as if clipping was not enabled).
+  */
+  Actor actors[5];
+  for( int i = 0; i < 5; ++i )
+  {
+    Texture image = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 16u, 16u );
+    Actor actor = CreateRenderableActor( image );
+
+    // Setup dimensions and position so actor is not skipped by culling.
+    actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
+    actor.SetProperty( Actor::Property::SIZE, Vector2( 16.0f, 16.0f ) );
+
+    if( i == 0 )
+    {
+      actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+    }
+    else
+    {
+      float b = i > 2 ? 1.0f : -1.0f;
+      actor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3( 0.5 + ( 0.2f * b ), 0.8f, 0.8f ) );
+    }
+
+    actors[i] = actor;
+  }
+
+  // Enable clipping on the actor at the top of the left branch.
+  actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+
+  // Build the scene graph.
+  application.GetScene().Add( actors[0] );
+
+  // Left branch:
+  actors[0].Add( actors[1] );
+  actors[1].Add( actors[2] );
+
+  // Right branch:
+  actors[0].Add( actors[3] );
+  actors[3].Add( actors[4] );
+
+  // Gather the call trace.
+  enabledDisableTrace.Reset();
+  enabledDisableTrace.Enable( true );
+  application.SendNotification();
+  application.Render();
+  enabledDisableTrace.Enable( false );
+
+  /* Check stencil is enabled and disabled again (as right-hand branch of tree is drawn).
+
+     Note: Correct enable call trace:    StackTrace: Index:0, Function:Enable, ParamList:3042 StackTrace: Index:1, Function:Enable, ParamList:2960 StackTrace: Index:2, Function:Disable, ParamList:2960
+           Incorrect enable call trace:  StackTrace: Index:0, Function:Enable, ParamList:3042 StackTrace: Index:1, Function:Enable, ParamList:2960
+  */
+  size_t startIndex = 0u;
+  DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable",  "3042", startIndex ) );
+  DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable",  "2960", startIndex ) ); // 2960 is GL_STENCIL_TEST
+  DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Disable", "2960", startIndex ) );
+
+  // Swap the clipping actor from top of left branch to top of right branch.
+  actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED );
+  actors[3].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+
+  // Gather the call trace.
+  enabledDisableTrace.Reset();
+  enabledDisableTrace.Enable( true );
+  application.SendNotification();
+  application.Render();
+  enabledDisableTrace.Enable( false );
+
+  // Check stencil is enabled but NOT disabled again (as right-hand branch of tree is drawn).
+  // This proves the draw order has remained the same.
+  startIndex = 0u;
+  DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex(  "Enable",  "2960", startIndex ) );
+  DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Disable", "2960", startIndex ) );
+
+  END_TEST;
+}
+
+int UtcDaliActorPropertyScissorClippingActor(void)
+{
+  // This test checks that an actor is correctly setup for clipping.
+  tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor" );
+  TestApplication application;
+
+  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+  TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+  TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+  const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
+  const Vector2 imageSize( 16.0f, 16.0f );
+
+  // Create a clipping actor.
+  Actor clippingActorA = CreateActorWithContent16x16();
+  // Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
+  // We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
+  clippingActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT );
+  clippingActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT );
+  clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+  application.GetScene().Add( clippingActorA );
+
+  // Gather the call trace.
+  GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+  // Check we are writing to the color buffer.
+  CheckColorMask( glAbstraction, true );
+
+  // Check scissor test was enabled.
+  DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
+
+  // Check the scissor was set, and the coordinates are correct.
+  std::stringstream compareParametersString;
+  compareParametersString << "0, 0, " << imageSize.x << ", " << imageSize.y;
+  DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) );                  // Compare with 0, 0, 16, 16
+
+  clippingActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT );
+  clippingActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_RIGHT );
+
+  // Gather the call trace.
+  GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+  // Check the scissor was set, and the coordinates are correct.
+  compareParametersString.str( std::string() );
+  compareParametersString.clear();
+  compareParametersString << ( stageSize.x - imageSize.x ) << ", " << ( stageSize.y - imageSize.y ) << ", " << imageSize.x << ", " << imageSize.y;
+  DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) );                  // Compare with 464, 784, 16, 16
+
+  END_TEST;
+}
+
+int UtcDaliActorPropertyScissorClippingActorSiblings(void)
+{
+  // This test checks that an actor is correctly setup for clipping.
+  tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actors which are siblings" );
+  TestApplication application;
+
+
+  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+  TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+  TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+  const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
+  const Vector2 sizeA{ stageSize.width, stageSize.height * 0.25f };
+  const Vector2 sizeB{ stageSize.width, stageSize.height * 0.05f };
+
+  // Create a clipping actors.
+  Actor clippingActorA = CreateActorWithContent( sizeA.width, sizeA.height );
+  Actor clippingActorB = CreateActorWithContent( sizeB.width, sizeB.height );
+
+  clippingActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
+  clippingActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
+  clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+  clippingActorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
+  clippingActorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
+  clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+  clippingActorA.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, -200.0f, 0.0f ));
+  clippingActorB.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 0.0f, 0.0f ));
+
+  application.GetScene().Add( clippingActorA );
+  application.GetScene().Add( clippingActorB );
+
+  // Gather the call trace.
+  GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+  // Check we are writing to the color buffer.
+  CheckColorMask( glAbstraction, true );
+
+  // Check scissor test was enabled.
+  DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
+
+  // Check the scissor was set, and the coordinates are correct.
+  std::stringstream compareParametersString;
+
+  std::string clipA( "0, 500, 480, 200" );
+  std::string clipB( "0, 380, 480, 40" );
+
+  DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipA ) );
+  DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipB ) );
+
+  END_TEST;
+}
+
+int UtcDaliActorPropertyScissorClippingActorNested01(void)
+{
+  // This test checks that an actor is correctly setup for clipping.
+  tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested" );
+  TestApplication application;
+
+  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+  TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+  TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+  const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
+  const Vector2 imageSize( 16.0f, 16.0f );
+
+  /* Create a nest of 2 scissors to test nesting (intersecting clips).
+
+     A is drawn first - with scissor clipping on
+     B is drawn second - also with scissor clipping on
+     C is the generated clipping region, the intersection ( A ∩ B )
+
+           ┏━━━━━━━┓                   ┌───────┐
+           ┃     B ┃                   │     B │
+       ┌───╂┄┄┄┐   ┃               ┌┄┄┄╆━━━┓   │
+       │   ┃   ┊   ┃     ━━━━━>    ┊   ┃ C ┃   │
+       │   ┗━━━┿━━━┛               ┊   ┗━━━╃───┘
+       │ A     │                   ┊ A     ┊
+       └───────┘                   └┄┄┄┄┄┄┄┘
+
+     We then reposition B around each corner of A to test the 4 overlap combinations (thus testing intersecting works correctly).
+  */
+
+  // Create a clipping actor.
+  Actor clippingActorA = CreateActorWithContent16x16();
+  // Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
+  // We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
+  clippingActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  clippingActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+  application.GetScene().Add( clippingActorA );
+
+  // Create a child clipping actor.
+  Actor clippingActorB = CreateActorWithContent16x16();
+  clippingActorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  clippingActorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+  clippingActorA.Add( clippingActorB );
+
+  // positionModifiers is an array of positions to position B around.
+  // expect is an array of expected scissor clip coordinate results.
+  const Vector2 positionModifiers[4] = { Vector2( 1.0f, 1.0f ),     Vector2( -1.0f, 1.0f ),    Vector2( -1.0f, -1.0f ),   Vector2( 1.0f, -1.0f )    };
+  const Vector4 expect[4] =            { Vector4( 240, 392, 8, 8 ), Vector4( 232, 392, 8, 8 ), Vector4( 232, 400, 8, 8 ), Vector4( 240, 400, 8, 8 ) };
+
+  // Loop through each overlap combination.
+  for( unsigned int test = 0u; test < 4u; ++test )
+  {
+    // Position the child clipping actor so it intersects with the 1st clipping actor. This changes each loop.
+    const Vector2 position = ( imageSize / 2.0f ) * positionModifiers[test];
+    clippingActorB.SetProperty( Actor::Property::POSITION, Vector2( position.x, position.y ));
+
+    // Gather the call trace.
+    GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+    // Check we are writing to the color buffer.
+    CheckColorMask( glAbstraction, true );
+
+    // Check scissor test was enabled.
+    DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
+
+    // Check the scissor was set, and the coordinates are correct.
+    const Vector4& expectResults( expect[test] );
+    std::stringstream compareParametersString;
+    compareParametersString << expectResults.x << ", " << expectResults.y << ", " << expectResults.z << ", " << expectResults.w;
+    DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) );                  // Compare with the expected result
+  }
+
+  END_TEST;
+}
+
+int UtcDaliActorPropertyScissorClippingActorNested02(void)
+{
+  // This test checks that an actor is correctly setup for clipping.
+  tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested" );
+  TestApplication application;
+
+  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+  TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+  TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+
+  /* Create a nest of 2 scissors and siblings of the parent.
+
+            stage
+              |
+        ┌─────┐─────┐
+        A     C     D
+        |           |
+        B           E
+  */
+
+  const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
+  const Vector2 sizeA{ stageSize.width, stageSize.height * 0.25f };
+  const Vector2 sizeB{ stageSize.width, stageSize.height * 0.05f };
+  const Vector2 sizeC{ stageSize.width, stageSize.height * 0.25f };
+  const Vector2 sizeD{ stageSize.width, stageSize.height * 0.25f };
+  const Vector2 sizeE{ stageSize.width, stageSize.height * 0.05f };
+
+  // Create a clipping actors.
+  Actor clippingActorA = CreateActorWithContent( sizeA.width, sizeA.height );
+  Actor clippingActorB = CreateActorWithContent( sizeB.width, sizeB.height );
+  Actor clippingActorC = CreateActorWithContent( sizeC.width, sizeC.height );
+  Actor clippingActorD = CreateActorWithContent( sizeD.width, sizeD.height );
+  Actor clippingActorE = CreateActorWithContent( sizeE.width, sizeE.height );
+
+  clippingActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
+  clippingActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
+  clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+  clippingActorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
+  clippingActorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
+  clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+  clippingActorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
+  clippingActorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
+  clippingActorC.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+  clippingActorD.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
+  clippingActorD.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
+  clippingActorD.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+  clippingActorE.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
+  clippingActorE.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
+
+  clippingActorA.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, -200.0f, 0.0f ));
+  clippingActorB.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 0.0f, 0.0f ));
+  clippingActorC.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 100.0f, 0.0f ));
+  clippingActorD.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 0.0f, 0.0f ));
+  clippingActorE.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 0.0f, 0.0f ));
+
+  application.GetScene().Add( clippingActorA );
+  clippingActorA.Add( clippingActorB );
+  application.GetScene().Add( clippingActorC );
+  application.GetScene().Add( clippingActorD );
+  clippingActorD.Add( clippingActorE );
+
+  // Gather the call trace.
+  GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+  // Check we are writing to the color buffer.
+  CheckColorMask( glAbstraction, true );
+
+  // Check scissor test was enabled.
+  DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );                                   // 3089 = 0xC11 (GL_SCISSOR_TEST)
+
+  // Check the scissor was set, and the coordinates are correct.
+  std::string clipA( "0, 500, 480, 200" );
+  std::string clipB( "0, 580, 480, 40" );
+  std::string clipC( "0, 200, 480, 200" );
+  std::string clipD( "0, 300, 480, 200" );
+
+  DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipA ) );
+  DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipB ) );
+  DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipC ) );
+  DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipD ) );
+  DALI_TEST_CHECK( scissorTrace.CountMethod( "Scissor" ) == 4 );    // Scissor rect should not be changed in clippingActorE case. So count should be 4.
+
+  END_TEST;
+}
+
 int UtcDaliActorPropertyClippingActorWithRendererOverride(void)
 {
   // This test checks that an actor with clipping will be ignored if overridden by the Renderer properties.
@@ -4229,9 +4759,9 @@ int UtcDaliActorPropertyClippingActorWithRendererOverride(void)
   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
 
   // Create a clipping actor.
-  Actor actorDepth1Clip = CreateActorWithContent();
+  Actor actorDepth1Clip = CreateActorWithContent16x16();
   actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
-  Stage::GetCurrent().Add( actorDepth1Clip );
+  application.GetScene().Add( actorDepth1Clip );
 
   // Turn the RenderMode to just "COLOR" at the Renderer level to ignore the clippingMode.
   actorDepth1Clip.GetRendererAt( 0 ).SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
@@ -4250,13 +4780,26 @@ int UtcDaliActorPropertyClippingActorWithRendererOverride(void)
   DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilMask" ) );
   DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilOp" ) );
 
+  // Check that scissor clipping is overriden by the renderer properties.
+  TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+
+  actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+
+  // Gather the call trace.
+  GenerateTrace( application, enabledDisableTrace, scissorTrace );
+
+  // Check the stencil buffer was not enabled.
+  DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) );    // 3089 = 0xC11 (GL_SCISSOR_TEST)
+
+  DALI_TEST_CHECK( !scissorTrace.FindMethod( "StencilFunc" ) );
+
   END_TEST;
 }
 
 int UtcDaliGetPropertyN(void)
 {
   tet_infoline( "Testing Actor::GetProperty returns a non valid value if property index is out of range" );
-  TestApplication app;
+  TestApplication application;
 
   Actor actor = Actor::New();
 
@@ -4271,20 +4814,22 @@ int UtcDaliActorRaiseLower(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Debug::Filter::SetGlobalLogLevel( Debug::Verbose );
+
+  Integration::Scene stage( application.GetScene() );
 
   Actor actorA = Actor::New();
   Actor actorB = Actor::New();
   Actor actorC = Actor::New();
 
-  actorA.SetAnchorPoint( AnchorPoint::CENTER );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorB.SetAnchorPoint( AnchorPoint::CENTER );
-  actorB.SetParentOrigin( ParentOrigin::CENTER );
+  actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorC.SetAnchorPoint( AnchorPoint::CENTER );
-  actorC.SetParentOrigin( ParentOrigin::CENTER );
+  actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
@@ -4310,9 +4855,15 @@ int UtcDaliActorRaiseLower(void)
 
   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
   // Only top actor will get touched.
-  actorA.TouchSignal().Connect( TestTouchCallback );
-  actorB.TouchSignal().Connect( TestTouchCallback2 );
-  actorC.TouchSignal().Connect( TestTouchCallback3 );
+  actorA.TouchedSignal().Connect( TestTouchCallback );
+  actorB.TouchedSignal().Connect( TestTouchCallback2 );
+  actorC.TouchedSignal().Connect( TestTouchCallback3 );
+
+  // Connect ChildOrderChangedSignal
+  bool orderChangedSignal( false );
+  Actor orderChangedActor;
+  ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+  DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
 
   Dali::Integration::Point point;
   point.SetDeviceId( 1 );
@@ -4337,7 +4888,11 @@ int UtcDaliActorRaiseLower(void)
   Property::Value value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
   value.Get( preActorOrder );
 
-  DevelActor::Raise( actorB );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorB.Raise();
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
   // Ensure sort order is calculated before next touch event
   application.SendNotification();
 
@@ -4359,7 +4914,13 @@ int UtcDaliActorRaiseLower(void)
   value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
   value.Get( preActorOrder );
 
-  DevelActor::Lower( actorB );
+  orderChangedSignal = false;
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorB.Lower();
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
   application.SendNotification(); // ensure sort order calculated before next touch event
 
   value  = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
@@ -4375,6 +4936,8 @@ int UtcDaliActorRaiseLower(void)
 
   ResetTouchCallbacks();
 
+  Debug::Filter::SetGlobalLogLevel( Debug::NoLogging );
+
   END_TEST;
 }
 
@@ -4384,7 +4947,7 @@ int UtcDaliActorRaiseToTopLowerToBottom(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   Actor actorA = Actor::New();
   Actor actorB = Actor::New();
@@ -4413,14 +4976,14 @@ int UtcDaliActorRaiseToTopLowerToBottom(void)
   Renderer rendererC = Renderer::New(geometry, shaderC);
   actorC.AddRenderer(rendererC);
 
-  actorA.SetAnchorPoint( AnchorPoint::CENTER );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorB.SetAnchorPoint( AnchorPoint::CENTER );
-  actorB.SetParentOrigin( ParentOrigin::CENTER );
+  actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorC.SetAnchorPoint( AnchorPoint::CENTER );
-  actorC.SetParentOrigin( ParentOrigin::CENTER );
+  actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
@@ -4437,6 +5000,12 @@ int UtcDaliActorRaiseToTopLowerToBottom(void)
 
   ResetTouchCallbacks();
 
+  // Connect ChildOrderChangedSignal
+  bool orderChangedSignal( false );
+  Actor orderChangedActor;
+  ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+  DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
   // Set up gl abstraction trace so can query the set uniform order
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableSetUniformCallTrace(true);
@@ -4465,9 +5034,9 @@ int UtcDaliActorRaiseToTopLowerToBottom(void)
 
   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
   // Only top actor will get touched.
-  actorA.TouchSignal().Connect( TestTouchCallback );
-  actorB.TouchSignal().Connect( TestTouchCallback2 );
-  actorC.TouchSignal().Connect( TestTouchCallback3 );
+  actorA.TouchedSignal().Connect( TestTouchCallback );
+  actorB.TouchedSignal().Connect( TestTouchCallback2 );
+  actorC.TouchedSignal().Connect( TestTouchCallback3 );
 
   Dali::Integration::Point point;
   point.SetDeviceId( 1 );
@@ -4486,7 +5055,11 @@ int UtcDaliActorRaiseToTopLowerToBottom(void)
 
   tet_printf( "RaiseToTop ActorA\n" );
 
-  DevelActor::RaiseToTop( actorA );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorA.RaiseToTop();
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+
   application.SendNotification(); // ensure sorting order is calculated before next touch event
 
   application.ProcessEvent( touchEvent );
@@ -4517,7 +5090,13 @@ int UtcDaliActorRaiseToTopLowerToBottom(void)
 
   tet_printf( "RaiseToTop ActorB\n" );
 
-  DevelActor::RaiseToTop( actorB );
+  orderChangedSignal = false;
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorB.RaiseToTop();
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
   application.SendNotification(); // Ensure sort order is calculated before next touch event
 
   application.ProcessEvent( touchEvent );
@@ -4548,11 +5127,23 @@ int UtcDaliActorRaiseToTopLowerToBottom(void)
 
   tet_printf( "LowerToBottom ActorA then ActorB leaving Actor C at Top\n" );
 
-  DevelActor::LowerToBottom( actorA );
+  orderChangedSignal = false;
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorA.LowerToBottom();
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+
   application.SendNotification();
   application.Render();
 
-  DevelActor::LowerToBottom( actorB );
+  orderChangedSignal = false;
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorB.LowerToBottom();
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
   application.SendNotification();
   application.Render();
 
@@ -4591,20 +5182,20 @@ int UtcDaliActorRaiseAbove(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   Actor actorA = Actor::New();
   Actor actorB = Actor::New();
   Actor actorC = Actor::New();
 
-  actorA.SetAnchorPoint( AnchorPoint::CENTER );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorB.SetAnchorPoint( AnchorPoint::CENTER );
-  actorB.SetParentOrigin( ParentOrigin::CENTER );
+  actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorC.SetAnchorPoint( AnchorPoint::CENTER );
-  actorC.SetParentOrigin( ParentOrigin::CENTER );
+  actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
@@ -4630,9 +5221,14 @@ int UtcDaliActorRaiseAbove(void)
 
   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
   // Only top actor will get touched.
-  actorA.TouchSignal().Connect( TestTouchCallback );
-  actorB.TouchSignal().Connect( TestTouchCallback2 );
-  actorC.TouchSignal().Connect( TestTouchCallback3 );
+  actorA.TouchedSignal().Connect( TestTouchCallback );
+  actorB.TouchedSignal().Connect( TestTouchCallback2 );
+  actorC.TouchedSignal().Connect( TestTouchCallback3 );
+
+  bool orderChangedSignal( false );
+  Actor orderChangedActor;
+  ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+  DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
 
   Dali::Integration::Point point;
   point.SetDeviceId( 1 );
@@ -4651,10 +5247,13 @@ int UtcDaliActorRaiseAbove(void)
 
   tet_printf( "Raise actor B Above Actor C\n" );
 
-  DevelActor::RaiseAbove( actorB, actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorB.RaiseAbove( actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
-
   application.ProcessEvent( touchEvent );
 
   DALI_TEST_EQUALS( gTouchCallBackCalled,  false, TEST_LOCATION );
@@ -4665,7 +5264,12 @@ int UtcDaliActorRaiseAbove(void)
 
   tet_printf( "Raise actor A Above Actor B\n" );
 
-  DevelActor::RaiseAbove( actorA, actorB );
+  orderChangedSignal = false;
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorA.RaiseAbove( actorB );
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
 
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
@@ -4687,7 +5291,7 @@ int UtcDaliActorLowerBelow(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   // Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
   // enables checking of which actor the uniform is assigned too
@@ -4716,14 +5320,14 @@ int UtcDaliActorLowerBelow(void)
   Renderer rendererC = Renderer::New(geometry, shaderC);
   actorC.AddRenderer(rendererC);
 
-  actorA.SetAnchorPoint( AnchorPoint::CENTER );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorB.SetAnchorPoint( AnchorPoint::CENTER );
-  actorB.SetParentOrigin( ParentOrigin::CENTER );
+  actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorC.SetAnchorPoint( AnchorPoint::CENTER );
-  actorC.SetParentOrigin( ParentOrigin::CENTER );
+  actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
@@ -4735,7 +5339,7 @@ int UtcDaliActorLowerBelow(void)
   actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
 
   Actor container = Actor::New();
-  container.SetParentOrigin( ParentOrigin::CENTER );
+  container.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
   container.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
   stage.Add( container );
 
@@ -4745,6 +5349,12 @@ int UtcDaliActorLowerBelow(void)
 
   ResetTouchCallbacks();
 
+  // Connect ChildOrderChangedSignal
+  bool orderChangedSignal( false );
+  Actor orderChangedActor;
+  ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+  DevelActor::ChildOrderChangedSignal( container ).Connect( &application, f ) ;
+
   // Set up gl abstraction trace so can query the set uniform order
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableSetUniformCallTrace(true);
@@ -4776,9 +5386,9 @@ int UtcDaliActorLowerBelow(void)
 
   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
   // Only top actor will get touched.
-  actorA.TouchSignal().Connect( TestTouchCallback );
-  actorB.TouchSignal().Connect( TestTouchCallback2 );
-  actorC.TouchSignal().Connect( TestTouchCallback3 );
+  actorA.TouchedSignal().Connect( TestTouchCallback );
+  actorB.TouchedSignal().Connect( TestTouchCallback2 );
+  actorC.TouchedSignal().Connect( TestTouchCallback3 );
 
   Dali::Integration::Point point;
   point.SetDeviceId( 1 );
@@ -4799,7 +5409,11 @@ int UtcDaliActorLowerBelow(void)
 
   tet_printf( "Lower actor C below Actor B ( actor B and A on same level due to insertion order) so C is below both \n" );
 
-  DevelActor::LowerBelow( actorC, actorB );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorC.LowerBelow( actorB );
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorC, TEST_LOCATION );
+
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
   application.Render();
@@ -4831,7 +5445,13 @@ int UtcDaliActorLowerBelow(void)
 
   tet_printf( "Lower actor C below Actor A leaving B on top\n" );
 
-  DevelActor::LowerBelow( actorC, actorA );
+  orderChangedSignal = false;
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorC.LowerBelow( actorA );
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorC, TEST_LOCATION );
+
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
   application.Render();
@@ -4860,7 +5480,13 @@ int UtcDaliActorLowerBelow(void)
 
   tet_printf( "Lower actor B below Actor C leaving A on top\n" );
 
-  DevelActor::LowerBelow( actorB, actorC );
+  orderChangedSignal = false;
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorB.LowerBelow( actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
   application.Render();
@@ -4891,7 +5517,7 @@ int UtcDaliActorRaiseAboveDifferentParentsN(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   Actor parentA = Actor::New();
   Actor parentB = Actor::New();
@@ -4900,11 +5526,11 @@ int UtcDaliActorRaiseAboveDifferentParentsN(void)
   parentB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
   parentB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
 
-  parentA.SetAnchorPoint( AnchorPoint::CENTER );
-  parentA.SetParentOrigin( ParentOrigin::CENTER );
+  parentA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  parentA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  parentB.SetAnchorPoint( AnchorPoint::CENTER );
-  parentB.SetParentOrigin( ParentOrigin::CENTER );
+  parentB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  parentB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
   stage.Add( parentA );
   stage.Add( parentB );
@@ -4919,14 +5545,14 @@ int UtcDaliActorRaiseAboveDifferentParentsN(void)
   tet_printf( "Actor C added to different parent from A and B \n" );
   parentB.Add( actorC );
 
-  actorA.SetAnchorPoint( AnchorPoint::CENTER );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorB.SetAnchorPoint( AnchorPoint::CENTER );
-  actorB.SetParentOrigin( ParentOrigin::CENTER );
+  actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorC.SetAnchorPoint( AnchorPoint::CENTER );
-  actorC.SetParentOrigin( ParentOrigin::CENTER );
+  actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
@@ -4939,6 +5565,12 @@ int UtcDaliActorRaiseAboveDifferentParentsN(void)
 
   ResetTouchCallbacks();
 
+  // Connect ChildOrderChangedSignal
+  bool orderChangedSignal( false );
+  Actor orderChangedActor;
+  ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+  DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
   application.SendNotification();
   application.Render();
 
@@ -4948,9 +5580,9 @@ int UtcDaliActorRaiseAboveDifferentParentsN(void)
 
   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
   // Only top actor will get touched.
-  actorA.TouchSignal().Connect( TestTouchCallback );
-  actorB.TouchSignal().Connect( TestTouchCallback2 );
-  actorC.TouchSignal().Connect( TestTouchCallback3 );
+  actorA.TouchedSignal().Connect( TestTouchCallback );
+  actorB.TouchedSignal().Connect( TestTouchCallback2 );
+  actorC.TouchedSignal().Connect( TestTouchCallback3 );
 
   Dali::Integration::Point point;
   point.SetDeviceId( 1 );
@@ -4969,7 +5601,10 @@ int UtcDaliActorRaiseAboveDifferentParentsN(void)
 
   tet_printf( "Raise actor A Above Actor C which have different parents\n" );
 
-  DevelActor::RaiseAbove( actorA, actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorA.RaiseAbove( actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
 
@@ -4990,20 +5625,20 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   Actor actorA = Actor::New();
   Actor actorB = Actor::New();
   Actor actorC = Actor::New();
 
-  actorA.SetAnchorPoint( AnchorPoint::CENTER );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorB.SetAnchorPoint( AnchorPoint::CENTER );
-  actorB.SetParentOrigin( ParentOrigin::CENTER );
+  actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorC.SetAnchorPoint( AnchorPoint::CENTER );
-  actorC.SetParentOrigin( ParentOrigin::CENTER );
+  actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
@@ -5016,6 +5651,12 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
 
   ResetTouchCallbacks();
 
+  // Connect ChildOrderChangedSignal
+  bool orderChangedSignal( false );
+  Actor orderChangedActor;
+  ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+  DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
   application.SendNotification();
   application.Render();
 
@@ -5025,9 +5666,9 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
 
   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
   // Only top actor will get touched.
-  actorA.TouchSignal().Connect( TestTouchCallback );
-  actorB.TouchSignal().Connect( TestTouchCallback2 );
-  actorC.TouchSignal().Connect( TestTouchCallback3 );
+  actorA.TouchedSignal().Connect( TestTouchCallback );
+  actorB.TouchedSignal().Connect( TestTouchCallback2 );
+  actorC.TouchedSignal().Connect( TestTouchCallback3 );
 
   Dali::Integration::Point point;
   point.SetDeviceId( 1 );
@@ -5038,7 +5679,10 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
 
   tet_printf( "Raise actor A Above Actor C which have no parents\n" );
 
-  DevelActor::RaiseAbove( actorA, actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorA.RaiseAbove( actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
 
@@ -5052,9 +5696,14 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
 
   ResetTouchCallbacks();
 
+  orderChangedSignal = false;
+
   stage.Add ( actorB );
   tet_printf( "Lower actor A below Actor C when only A is not on stage \n" );
-  DevelActor::LowerBelow( actorA, actorC );
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorA.LowerBelow( actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
 
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
@@ -5069,6 +5718,8 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
 
   ResetTouchCallbacks();
 
+  orderChangedSignal = false;
+
   tet_printf( "Adding Actor A to stage, will be on top\n" );
 
   stage.Add ( actorA );
@@ -5076,7 +5727,11 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
   application.Render();
 
   tet_printf( "Raise actor B Above Actor C when only B has a parent\n" );
-  DevelActor::RaiseAbove( actorB, actorC );
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorB.RaiseAbove( actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
 
@@ -5089,8 +5744,14 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
 
   ResetTouchCallbacks();
 
+  orderChangedSignal = false;
+
   tet_printf( "Lower actor A below Actor C when only A has a parent\n" );
-  DevelActor::LowerBelow( actorA, actorC );
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorA.LowerBelow( actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
 
@@ -5103,8 +5764,15 @@ int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
 
   ResetTouchCallbacks();
 
+  orderChangedSignal = false;
+
   stage.Add ( actorC );
-  DevelActor::RaiseAbove( actorA, actorC );
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorA.RaiseAbove( actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+
   // Ensure sorting happens at end of Core::ProcessEvents() before next touch
   application.SendNotification();
   application.Render();
@@ -5125,20 +5793,20 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   Actor actorA = Actor::New();
   Actor actorB = Actor::New();
   Actor actorC = Actor::New();
 
-  actorA.SetAnchorPoint( AnchorPoint::CENTER );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorB.SetAnchorPoint( AnchorPoint::CENTER );
-  actorB.SetParentOrigin( ParentOrigin::CENTER );
+  actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorC.SetAnchorPoint( AnchorPoint::CENTER );
-  actorC.SetParentOrigin( ParentOrigin::CENTER );
+  actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
@@ -5151,11 +5819,17 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void)
 
   ResetTouchCallbacks();
 
+  // Connect ChildOrderChangedSignal
+  bool orderChangedSignal( false );
+  Actor orderChangedActor;
+  ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+  DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
   // Only top actor will get touched.
-  actorA.TouchSignal().Connect( TestTouchCallback );
-  actorB.TouchSignal().Connect( TestTouchCallback2 );
-  actorC.TouchSignal().Connect( TestTouchCallback3 );
+  actorA.TouchedSignal().Connect( TestTouchCallback );
+  actorB.TouchedSignal().Connect( TestTouchCallback2 );
+  actorC.TouchedSignal().Connect( TestTouchCallback3 );
 
   Dali::Integration::Point point;
   point.SetDeviceId( 1 );
@@ -5166,7 +5840,10 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void)
 
   stage.Add ( actorA );
   tet_printf( "Raise actor B Above Actor C but B not parented\n" );
-  DevelActor::Raise( actorB );
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorB.Raise();
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
 
   application.SendNotification();
   application.Render();
@@ -5182,7 +5859,12 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void)
   tet_printf( "Raise actor B Above Actor C but B not parented\n" );
   ResetTouchCallbacks();
 
-  DevelActor::Lower( actorC );
+  orderChangedSignal = false;
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorC.Lower();
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
   // Sort actor tree before next touch event
   application.SendNotification();
   application.Render();
@@ -5196,9 +5878,14 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void)
   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
   ResetTouchCallbacks();
 
+  orderChangedSignal = false;
+
   tet_printf( "Lower actor C below B but C not parented\n" );
 
-  DevelActor::Lower( actorB );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorB.Lower();
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
   // Sort actor tree before next touch event
   application.SendNotification();
   application.Render();
@@ -5212,9 +5899,14 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void)
   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
   ResetTouchCallbacks();
 
+  orderChangedSignal = false;
+
   tet_printf( "Raise actor B to top\n" );
 
-  DevelActor::RaiseToTop( actorB );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorB.RaiseToTop();
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
   // Sort actor tree before next touch event
   application.SendNotification();
   application.Render();
@@ -5228,13 +5920,18 @@ int UtcDaliActorTestAllAPIwhenActorNotParented(void)
   DALI_TEST_EQUALS( gTouchCallBackCalled3,  false , TEST_LOCATION );
   ResetTouchCallbacks();
 
+  orderChangedSignal = false;
+
   tet_printf( "Add ActorB to stage so only Actor C not parented\n" );
 
   stage.Add ( actorB );
 
   tet_printf( "Lower actor C to Bottom, B stays at top\n" );
 
-  DevelActor::LowerToBottom( actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorC.LowerToBottom();
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+
   application.SendNotification();
   application.Render();
 
@@ -5257,20 +5954,20 @@ int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   Actor actorA = Actor::New();
   Actor actorB = Actor::New();
   Actor actorC = Actor::New();
 
-  actorA.SetAnchorPoint( AnchorPoint::CENTER );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorB.SetAnchorPoint( AnchorPoint::CENTER );
-  actorB.SetParentOrigin( ParentOrigin::CENTER );
+  actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
-  actorC.SetAnchorPoint( AnchorPoint::CENTER );
-  actorC.SetParentOrigin( ParentOrigin::CENTER );
+  actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 
   actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
   actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
@@ -5287,12 +5984,18 @@ int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void)
 
   // connect to actor touch signals, will use touch callbacks to determine which actor is on top.
   // Only top actor will get touched.
-  actorA.TouchSignal().Connect( TestTouchCallback );
-  actorB.TouchSignal().Connect( TestTouchCallback2 );
-  actorC.TouchSignal().Connect( TestTouchCallback3 );
+  actorA.TouchedSignal().Connect( TestTouchCallback );
+  actorB.TouchedSignal().Connect( TestTouchCallback2 );
+  actorC.TouchedSignal().Connect( TestTouchCallback3 );
 
   ResetTouchCallbacks();
 
+  // Connect ChildOrderChangedSignal
+  bool orderChangedSignal( false );
+  Actor orderChangedActor;
+  ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
+  DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+
   application.SendNotification();
   application.Render();
 
@@ -5313,7 +6016,11 @@ int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void)
 
   tet_infoline( "Raise actor A Above Actor A which is the same actor!!\n" );
 
-  DevelActor::RaiseAbove( actorA, actorA );
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorA.RaiseAbove( actorA );
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+
   application.SendNotification();
   application.Render();
 
@@ -5327,7 +6034,13 @@ int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void)
 
   ResetTouchCallbacks();
 
-  DevelActor::RaiseAbove( actorA, actorC );
+  orderChangedSignal = false;
+
+  DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+  actorA.RaiseAbove( actorC );
+  DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+
   application.SendNotification();
   application.Render();
 
@@ -5347,15 +6060,15 @@ int UtcDaliActorGetScreenPosition(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   Actor actorA = Actor::New();
-  actorA.SetAnchorPoint( AnchorPoint::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
 
   Vector2 size2( 10.0f, 20.0f );
-  actorA.SetSize( size2 );
+  actorA.SetProperty( Actor::Property::SIZE, size2 );
 
-  actorA.SetPosition( 0.f, 0.f );
+  actorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
 
   tet_infoline( "UtcDaliActorGetScreenPosition Center Anchor Point and 0,0 position \n" );
 
@@ -5365,7 +6078,7 @@ int UtcDaliActorGetScreenPosition(void)
   application.Render();
 
   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  Vector2 actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::CENTER \n",  actorWorldPosition.x, actorWorldPosition.y  );
   tet_printf( "Actor Screen Position %f %f \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5375,13 +6088,13 @@ int UtcDaliActorGetScreenPosition(void)
 
   tet_infoline( "UtcDaliActorGetScreenPosition Top Left Anchor Point and 0,0 position \n" );
 
-  actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
 
   application.SendNotification();
   application.Render();
 
   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position  ( %f %f ) AnchorPoint::TOP_LEFT  \n",  actorWorldPosition.x, actorWorldPosition.y );
   tet_printf( "Actor Screen Position  ( %f %f ) AnchorPoint::TOP_LEFT \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5391,13 +6104,13 @@ int UtcDaliActorGetScreenPosition(void)
 
   tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 0,0 position \n" );
 
-  actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
 
   application.SendNotification();
   application.Render();
 
   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT   \n",  actorWorldPosition.x, actorWorldPosition.y );
   tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT  \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5407,13 +6120,13 @@ int UtcDaliActorGetScreenPosition(void)
 
   tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,0 position \n" );
 
-  actorA.SetPosition( 30.0, 0.0 );
+  actorA.SetProperty( Actor::Property::POSITION, Vector2( 30.0, 0.0 ));
 
   application.SendNotification();
   application.Render();
 
   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0 \n",  actorWorldPosition.x, actorWorldPosition.y );
   tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0   \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5423,13 +6136,13 @@ int UtcDaliActorGetScreenPosition(void)
 
   tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,420 position \n" );
 
-  actorA.SetPosition( 30.0, 420.0 );
+  actorA.SetProperty( Actor::Property::POSITION, Vector2( 30.0, 420.0 ));
 
   application.SendNotification();
   application.Render();
 
   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   DALI_TEST_EQUALS( actorScreenPosition.x,  30lu , TEST_LOCATION );
   DALI_TEST_EQUALS( actorScreenPosition.y,  420lu , TEST_LOCATION );
@@ -5437,6 +6150,26 @@ int UtcDaliActorGetScreenPosition(void)
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0\n",  actorWorldPosition.x, actorWorldPosition.y );
   tet_printf( "Actor Screen Position( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0 \n", actorScreenPosition.x, actorScreenPosition.y );
 
+  tet_infoline( "UtcDaliActorGetScreenPosition Scale parent and check child's screen position \n" );
+
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+  actorA.SetProperty( Actor::Property::POSITION, Vector2( 30.0, 30.0 ));
+
+  Actor actorB = Actor::New();
+  actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+  actorB.SetProperty( Actor::Property::SIZE, size2 );
+  actorB.SetProperty( Actor::Property::POSITION, Vector2( 10.f, 10.f ));
+  actorA.Add( actorB );
+
+  actorA.SetProperty( Actor::Property::SCALE, 2.0f );
+
+  application.SendNotification();
+  application.Render();
+
+  actorScreenPosition = actorB.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+
+  DALI_TEST_EQUALS( actorScreenPosition.x,  50lu , TEST_LOCATION );
+  DALI_TEST_EQUALS( actorScreenPosition.y,  50lu , TEST_LOCATION );
 
   END_TEST;
 }
@@ -5447,15 +6180,15 @@ int UtcDaliActorGetScreenPositionAfterScaling(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   Actor actorA = Actor::New();
-  actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
 
   Vector2 size2( 10.0f, 20.0f );
-  actorA.SetSize( size2 );
-  actorA.SetScale( 1.5f );
-  actorA.SetPosition( 0.f, 0.f );
+  actorA.SetProperty( Actor::Property::SIZE, size2 );
+  actorA.SetProperty( Actor::Property::SCALE, 1.5f );
+  actorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
 
   tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling TopRight Anchor Point, scale 1.5f and 0,0 position \n" );
 
@@ -5465,7 +6198,7 @@ int UtcDaliActorGetScreenPositionAfterScaling(void)
   application.Render();
 
   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  Vector2 actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT \n",  actorWorldPosition.x, actorWorldPosition.y  );
   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5475,13 +6208,13 @@ int UtcDaliActorGetScreenPositionAfterScaling(void)
 
   tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling BOTTOM_RIGHT Anchor Point, scale 1.5f and 0,0 position \n" );
 
-  actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
 
   application.SendNotification();
   application.Render();
 
   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n",  actorWorldPosition.x, actorWorldPosition.y  );
   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5498,14 +6231,14 @@ int UtcDaliActorGetScreenPositionWithDifferentParentOrigin(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   Actor actorA = Actor::New();
-  actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
   Vector2 size2( 10.0f, 20.0f );
-  actorA.SetSize( size2 );
-  actorA.SetPosition( 0.f, 0.f );
+  actorA.SetProperty( Actor::Property::SIZE, size2 );
+  actorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
 
   tet_infoline( " TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
 
@@ -5515,7 +6248,7 @@ int UtcDaliActorGetScreenPositionWithDifferentParentOrigin(void)
   application.Render();
 
   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  Vector2 actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n",  actorWorldPosition.x, actorWorldPosition.y  );
   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5525,14 +6258,14 @@ int UtcDaliActorGetScreenPositionWithDifferentParentOrigin(void)
 
   tet_infoline( " BOTTOM_RIGHT Anchor Point, ParentOrigin::TOP_RIGHT and 0,0 position \n" );
 
-  actorA.SetParentOrigin( ParentOrigin::TOP_RIGHT );
-  actorA.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
 
   application.SendNotification();
   application.Render();
 
   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT ParentOrigin::TOP_RIGHT \n",  actorWorldPosition.x, actorWorldPosition.y  );
   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5550,25 +6283,25 @@ int UtcDaliActorGetScreenPositionWithChildActors(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   tet_infoline( "Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
 
   Actor actorA = Actor::New();
-  actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
   Vector2 size1( 10.0f, 20.0f );
-  actorA.SetSize( size1 );
-  actorA.SetPosition( 0.f, 0.f );
+  actorA.SetProperty( Actor::Property::SIZE, size1 );
+  actorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
 
   tet_infoline( "Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
 
   Actor parentActorA = Actor::New();
-  parentActorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  parentActorA.SetParentOrigin( ParentOrigin::CENTER );
+  parentActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+  parentActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
   Vector2 size2( 30.0f, 60.0f );
-  parentActorA.SetSize( size2 );
-  parentActorA.SetPosition( 0.f, 0.f );
+  parentActorA.SetProperty( Actor::Property::SIZE, size2 );
+  parentActorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
 
   tet_infoline( "Add child 1 to Parent 1 and check screen position \n" );
 
@@ -5579,7 +6312,7 @@ int UtcDaliActorGetScreenPositionWithChildActors(void)
   application.Render();
 
   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  Vector2 actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n",  actorWorldPosition.x, actorWorldPosition.y  );
   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5591,14 +6324,14 @@ int UtcDaliActorGetScreenPositionWithChildActors(void)
 
   tet_infoline( "change parent anchor point and parent origin then check screen position \n" );
 
-  parentActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
-  parentActorA.SetParentOrigin( ParentOrigin::TOP_LEFT );
+  parentActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT );
+  parentActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
 
   application.SendNotification();
   application.Render();
 
   actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_LEFT ParentOrigin::TOP_LEFT  \n",  actorWorldPosition.x, actorWorldPosition.y  );
   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5615,34 +6348,34 @@ int UtcDaliActorGetScreenPositionWithChildActors02(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   tet_infoline( "Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
 
   Actor actorA = Actor::New();
-  actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
   Vector2 size1( 10.0f, 20.0f );
-  actorA.SetSize( size1 );
-  actorA.SetPosition( 0.f, 0.f );
+  actorA.SetProperty( Actor::Property::SIZE, size1 );
+  actorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
 
   tet_infoline( "Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
 
   Actor parentActorA = Actor::New();
-  parentActorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  parentActorA.SetParentOrigin( ParentOrigin::CENTER );
+  parentActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+  parentActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
   Vector2 size2( 30.0f, 60.0f );
-  parentActorA.SetSize( size2 );
-  parentActorA.SetPosition( 0.f, 0.f );
+  parentActorA.SetProperty( Actor::Property::SIZE, size2 );
+  parentActorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
 
   tet_infoline( "Create Grand Parent Actor 1 BOTTOM_LEFT Anchor Point, ParentOrigin::BOTTOM_LEFT and 0,0 position \n" );
 
   Actor grandParentActorA = Actor::New();
-  grandParentActorA.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT );
-  grandParentActorA.SetParentOrigin( ParentOrigin::BOTTOM_LEFT );
+  grandParentActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT );
+  grandParentActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT );
   Vector2 size3( 60.0f, 120.0f );
-  grandParentActorA.SetSize( size3 );
-  grandParentActorA.SetPosition( 0.f, 0.f );
+  grandParentActorA.SetProperty( Actor::Property::SIZE, size3 );
+  grandParentActorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
 
   tet_infoline( "Add Parent 1 to Grand Parent 1 \n" );
 
@@ -5657,7 +6390,7 @@ int UtcDaliActorGetScreenPositionWithChildActors02(void)
   application.Render();
 
   Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
-  Vector2 actorScreenPosition = actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >();
+  Vector2 actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
 
   tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER  \n",  actorWorldPosition.x, actorWorldPosition.y  );
   tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
@@ -5674,35 +6407,35 @@ int UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse(void)
 
   TestApplication application;
 
-  Stage stage( Stage::GetCurrent() );
+  Integration::Scene stage( application.GetScene() );
 
   tet_infoline( "Create an actor with AnchorPoint::TOP_LEFT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
 
   Actor actorA = Actor::New();
-  actorA.SetAnchorPoint( AnchorPoint::TOP_LEFT );
-  actorA.SetParentOrigin( ParentOrigin::CENTER );
-  actorA.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
-  actorA.SetSize( 10.0f, 20.0f );
+  actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+  actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  actorA.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
+  actorA.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 20.0f ) );
   stage.Add( actorA );
 
   tet_infoline( "Create an Actor with AnchorPoint::BOTTOM_RIGHT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
 
   Actor actorB = Actor::New();
-  actorB.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
-  actorB.SetParentOrigin( ParentOrigin::CENTER );
-  actorB.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
+  actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
+  actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  actorB.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
   Vector2 actorBSize( 30.0f, 60.0f );
-  actorB.SetSize( actorBSize );
+  actorB.SetProperty( Actor::Property::SIZE, actorBSize );
   stage.Add( actorB );
 
   tet_infoline( "Create an actor with AnchorPoint::CENTER, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
 
   Actor actorC = Actor::New();
-  actorC.SetAnchorPoint( AnchorPoint::CENTER );
-  actorC.SetParentOrigin( ParentOrigin::CENTER );
-  actorC.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
+  actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  actorC.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
   Vector2 actorCSize( 60.0f, 120.0f );
-  actorC.SetSize( actorCSize );
+  actorC.SetProperty( Actor::Property::SIZE, actorCSize );
   stage.Add( actorC );
 
   application.SendNotification();
@@ -5712,22 +6445,22 @@ int UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse(void)
 
   Vector2 center( stage.GetSize() * 0.5f );
 
-  DALI_TEST_EQUALS( actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
-  DALI_TEST_EQUALS( actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
-  DALI_TEST_EQUALS( actorC.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
+  DALI_TEST_EQUALS( actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
+  DALI_TEST_EQUALS( actorB.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
+  DALI_TEST_EQUALS( actorC.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
 
   tet_infoline( "Add scale to all actors" );
 
-  actorA.SetScale( 2.0f );
-  actorB.SetScale( 2.0f );
-  actorC.SetScale( 2.0f );
+  actorA.SetProperty( Actor::Property::SCALE, 2.0f );
+  actorB.SetProperty( Actor::Property::SCALE, 2.0f );
+  actorC.SetProperty( Actor::Property::SCALE, 2.0f );
 
   application.SendNotification();
   application.Render();
 
-  DALI_TEST_EQUALS( actorA.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center /* TOP_LEFT Anchor */, TEST_LOCATION );
-  DALI_TEST_EQUALS( actorB.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorBSize /* BOTTOM_RIGHT Anchor */, TEST_LOCATION );
-  DALI_TEST_EQUALS( actorC.GetProperty( DevelActor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorCSize * 0.5f /* CENTER Anchor*/, TEST_LOCATION );
+  DALI_TEST_EQUALS( actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center /* TOP_LEFT Anchor */, TEST_LOCATION );
+  DALI_TEST_EQUALS( actorB.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorBSize /* BOTTOM_RIGHT Anchor */, TEST_LOCATION );
+  DALI_TEST_EQUALS( actorC.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorCSize * 0.5f /* CENTER Anchor*/, TEST_LOCATION );
 
   END_TEST;
 }
@@ -5738,25 +6471,25 @@ int utcDaliActorPositionUsesAnchorPoint(void)
   tet_infoline( "Check default behaviour\n" );
 
   Actor actor = Actor::New();
-  actor.SetParentOrigin( ParentOrigin::CENTER );
-  actor.SetAnchorPoint( AnchorPoint::CENTER );
-  actor.SetSize( 100.0f, 100.0f );
-  Stage::GetCurrent().Add( actor );
+  actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+  application.GetScene().Add( actor );
 
   application.SendNotification();
   application.Render();
 
   tet_infoline( "Check that the world position is in the center\n" );
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
 
   tet_infoline( "Set the position uses anchor point property to false\n" );
-  actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
+  actor.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
 
   application.SendNotification();
   application.Render();
 
   tet_infoline( "Check that the world position has changed appropriately\n" );
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
 
   END_TEST;
 }
@@ -5767,30 +6500,30 @@ int utcDaliActorPositionUsesAnchorPointCheckScale(void)
   tet_infoline( "Check that the scale is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
 
   Actor actor = Actor::New();
-  actor.SetParentOrigin( ParentOrigin::CENTER );
-  actor.SetAnchorPoint( AnchorPoint::CENTER );
-  actor.SetSize( 100.0f, 100.0f );
-  actor.SetScale( 2.0f );
-  actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
-  Stage::GetCurrent().Add( actor );
+  actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+  actor.SetProperty( Actor::Property::SCALE, 2.0f );
+  actor.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
+  application.GetScene().Add( actor );
 
   application.SendNotification();
   application.Render();
 
   tet_infoline( "Check the world position is the same as it would be without a scale\n" );
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
 
   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
-  actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 100.0f, 100.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 100.0f, 100.0f, 0.0f ), TEST_LOCATION );
 
   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
-  actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
 
   END_TEST;
 }
@@ -5801,30 +6534,30 @@ int utcDaliActorPositionUsesAnchorPointCheckRotation(void)
   tet_infoline( "Check that the rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
 
   Actor actor = Actor::New();
-  actor.SetParentOrigin( ParentOrigin::CENTER );
-  actor.SetAnchorPoint( AnchorPoint::CENTER );
-  actor.SetSize( 100.0f, 100.0f );
-  actor.SetOrientation( Degree( 90.0f), Vector3::ZAXIS );
-  actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
-  Stage::GetCurrent().Add( actor );
+  actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+  actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Degree( 90.0f), Vector3::ZAXIS ) );
+  actor.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
+  application.GetScene().Add( actor );
 
   application.SendNotification();
   application.Render();
 
   tet_infoline( "Check the world position is the same as it would be without a rotation\n" );
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
 
   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
-  actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( -50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( -50.0f, 50.0f, 0.0f ), TEST_LOCATION );
 
   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
-  actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 150.0f, 50.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 150.0f, 50.0f, 0.0f ), TEST_LOCATION );
 
   END_TEST;
 }
@@ -5835,31 +6568,31 @@ int utcDaliActorPositionUsesAnchorPointCheckScaleAndRotation(void)
   tet_infoline( "Check that the scale and rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
 
   Actor actor = Actor::New();
-  actor.SetParentOrigin( ParentOrigin::CENTER );
-  actor.SetAnchorPoint( AnchorPoint::CENTER );
-  actor.SetSize( 100.0f, 100.0f );
-  actor.SetOrientation( Degree( 90.0f), Vector3::ZAXIS );
-  actor.SetScale( 2.0f );
-  actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
-  Stage::GetCurrent().Add( actor );
+  actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+  actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Degree( 90.0f), Vector3::ZAXIS ) );
+  actor.SetProperty( Actor::Property::SCALE, 2.0f );
+  actor.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
+  application.GetScene().Add( actor );
 
   application.SendNotification();
   application.Render();
 
   tet_infoline( "Check the world position is the same as it would be without a scale and rotation\n" );
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
 
   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
-  actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( -100.0f, 100.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( -100.0f, 100.0f, 0.0f ), TEST_LOCATION );
 
   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
-  actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), Vector3( 200.0f, 0.0f, 0.0f ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 200.0f, 0.0f, 0.0f ), TEST_LOCATION );
 
   END_TEST;
 }
@@ -5871,16 +6604,16 @@ int utcDaliActorPositionUsesAnchorPointOnlyInheritPosition(void)
 
   Actor parent = Actor::New();
 
-  Stage::GetCurrent().Add( parent );
-  Vector2 stageSize( Stage::GetCurrent().GetSize() );
+  application.GetScene().Add( parent );
+  Vector2 stageSize( application.GetScene().GetSize() );
 
   Actor actor = Actor::New();
-  actor.SetParentOrigin( ParentOrigin::CENTER );
-  actor.SetAnchorPoint( AnchorPoint::CENTER );
-  actor.SetSize( 100.0f, 100.0f );
-  actor.SetInheritScale( false );
-  actor.SetInheritOrientation( false );
-  actor.SetProperty( DevelActor::Property::POSITION_USES_ANCHOR_POINT, false );
+  actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+  actor.SetProperty( Actor::Property::INHERIT_SCALE, false );
+  actor.SetProperty( Actor::Property::INHERIT_ORIENTATION, false );
+  actor.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
   parent.Add( actor );
 
   application.SendNotification();
@@ -5889,19 +6622,19 @@ int utcDaliActorPositionUsesAnchorPointOnlyInheritPosition(void)
   const Vector3 expectedWorldPosition( -stageSize.width * 0.5f + 50.0f, -stageSize.height * 0.5f + 50.0f, 0.0f );
 
   tet_infoline( "Check the world position is in the right place\n" );
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), expectedWorldPosition, TEST_LOCATION );
 
   tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure world position hasn't changed" );
-  actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), expectedWorldPosition, TEST_LOCATION );
 
   tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure world position hasn't changed" );
-  actor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT );
+  actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
   application.SendNotification();
   application.Render();
-  DALI_TEST_EQUALS( actor.GetCurrentWorldPosition(), expectedWorldPosition, TEST_LOCATION );
+  DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), expectedWorldPosition, TEST_LOCATION );
 
   END_TEST;
 }
@@ -5916,14 +6649,14 @@ int utcDaliActorVisibilityChangeSignalSelf(void)
   VisibilityChangedFunctorData data;
   DevelActor::VisibilityChangedSignal( actor ).Connect( &application, VisibilityChangedFunctor( data ) );
 
-  actor.SetVisible( false );
+  actor.SetProperty( Actor::Property::VISIBLE, false );
 
   data.Check( true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
 
   tet_infoline( "Ensure functor is not called if we attempt to change the visibility to what it already is at" );
   data.Reset();
 
-  actor.SetVisible( false );
+  actor.SetProperty( Actor::Property::VISIBLE, false );
   data.Check( false /* not called */, TEST_LOCATION );
 
   tet_infoline( "Change the visibility using properties, ensure called" );
@@ -5961,7 +6694,7 @@ int utcDaliActorVisibilityChangeSignalChildren(void)
   DevelActor::VisibilityChangedSignal( child ).Connect( &application, VisibilityChangedFunctor( childData ) );
   DevelActor::VisibilityChangedSignal( grandChild ).Connect( &application, VisibilityChangedFunctor( grandChildData ) );
 
-  parent.SetVisible( false );
+  parent.SetProperty( Actor::Property::VISIBLE, false );
   parentData.Check( false /* not called */, TEST_LOCATION );
   childData.Check( true /* called */, child, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
   grandChildData.Check( true /* called */, grandChild, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
@@ -5973,7 +6706,7 @@ int utcDaliActorVisibilityChangeSignalChildren(void)
 
   DevelActor::VisibilityChangedSignal( parent ).Connect( &application, VisibilityChangedFunctor( parentData ) );
 
-  parent.SetVisible( true );
+  parent.SetProperty( Actor::Property::VISIBLE, true );
   parentData.Check( true /* called */, parent, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
   childData.Check( true /* called */, child, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
   grandChildData.Check( true /* called */, grandChild, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
@@ -5983,7 +6716,7 @@ int utcDaliActorVisibilityChangeSignalChildren(void)
   childData.Reset();
   grandChildData.Reset();
 
-  parent.SetVisible( true );
+  parent.SetProperty( Actor::Property::VISIBLE, true );
   parentData.Check( false /* not called */, TEST_LOCATION );
   childData.Check( false /* not called */, TEST_LOCATION );
   grandChildData.Check( false /* not called */, TEST_LOCATION );
@@ -5997,7 +6730,7 @@ int utcDaliActorVisibilityChangeSignalAfterAnimation(void)
   tet_infoline( "Check that the visibility change signal is emitted when the visibility changes when an animation starts" );
 
   Actor actor = Actor::New();
-  Stage::GetCurrent().Add( actor );
+  application.GetScene().Add( actor );
 
   application.SendNotification();
   application.Render();
@@ -6028,3 +6761,1824 @@ int utcDaliActorVisibilityChangeSignalAfterAnimation(void)
 
   END_TEST;
 }
+
+
+int utcDaliActorVisibilityChangeSignalByName(void)
+{
+  TestApplication application;
+  tet_infoline( "Check that the visibility change signal is called when the visibility changes for the actor itself" );
+
+  Actor actor = Actor::New();
+
+  bool signalCalled=false;
+  actor.ConnectSignal( &application, "visibilityChanged", VisibilityChangedVoidFunctor(signalCalled) );
+  DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+  actor.SetProperty( Actor::Property::VISIBLE, false );
+  DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
+
+  tet_infoline( "Ensure functor is not called if we attempt to change the visibility to what it already is at" );
+  signalCalled = false;
+  actor.SetProperty( Actor::Property::VISIBLE, false );
+  DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+
+  tet_infoline( "Change the visibility using properties, ensure called" );
+  actor.SetProperty( Actor::Property::VISIBLE, true );
+  DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
+
+  tet_infoline( "Set the visibility to current using properties, ensure not called" );
+  signalCalled = false;
+
+  actor.SetProperty( Actor::Property::VISIBLE, true );
+  DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+
+  END_TEST;
+}
+
+
+static void LayoutDirectionChanged( Actor actor, LayoutDirection::Type type )
+{
+  gLayoutDirectionType = type;
+}
+
+int UtcDaliActorLayoutDirectionProperty(void)
+{
+  TestApplication application;
+  tet_infoline( "Check layout direction property" );
+
+  Actor actor0 = Actor::New();
+  DALI_TEST_EQUALS( actor0.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  application.GetScene().Add( actor0 );
+
+  application.SendNotification();
+  application.Render();
+
+  Actor actor1 = Actor::New();
+  DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  Actor actor2 = Actor::New();
+  DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  Actor actor3 = Actor::New();
+  DALI_TEST_EQUALS( actor3.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  Actor actor4 = Actor::New();
+  DALI_TEST_EQUALS( actor4.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  Actor actor5 = Actor::New();
+  DALI_TEST_EQUALS( actor5.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  Actor actor6 = Actor::New();
+  DALI_TEST_EQUALS( actor6.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  Actor actor7 = Actor::New();
+  DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  Actor actor8 = Actor::New();
+  DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  Actor actor9 = Actor::New();
+  DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+
+  actor1.Add( actor2 );
+  gLayoutDirectionType = LayoutDirection::LEFT_TO_RIGHT;
+  actor2.LayoutDirectionChangedSignal().Connect( LayoutDirectionChanged );
+
+  DALI_TEST_EQUALS( actor1.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), true, TEST_LOCATION );
+  actor1.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
+  DALI_TEST_EQUALS( actor1.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), false, TEST_LOCATION );
+
+  DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( gLayoutDirectionType, LayoutDirection::RIGHT_TO_LEFT, TEST_LOCATION );
+
+  actor1.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, true );
+  actor0.Add( actor1 );
+  DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+
+  application.GetScene().Add( actor3 );
+  actor3.Add( actor4 );
+  actor4.Add( actor5 );
+  actor5.Add( actor6 );
+  actor5.Add( actor7 );
+  actor7.Add( actor8 );
+  actor8.Add( actor9 );
+  actor3.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
+  actor5.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
+
+  DALI_TEST_EQUALS( actor8.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), true, TEST_LOCATION );
+  actor8.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, false );
+  DALI_TEST_EQUALS( actor8.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), false, TEST_LOCATION );
+
+  actor7.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
+
+  DALI_TEST_EQUALS( actor3.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor4.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor5.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor6.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+
+  actor8.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
+  DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+
+  actor7.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
+  DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+
+  actor8.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, true );
+  DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+
+  END_TEST;
+}
+
+
+struct LayoutDirectionFunctor
+{
+  LayoutDirectionFunctor(bool& signalCalled)
+  : mSignalCalled( signalCalled )
+  {
+  }
+
+  LayoutDirectionFunctor(const LayoutDirectionFunctor& rhs)
+  : mSignalCalled( rhs.mSignalCalled )
+  {
+  }
+
+  void operator()()
+  {
+    mSignalCalled = true;
+  }
+
+  bool& mSignalCalled;
+};
+
+int UtcDaliActorLayoutDirectionSignal(void)
+{
+  TestApplication application;
+  tet_infoline( "Check changing layout direction property sends a signal" );
+
+  Actor actor = Actor::New();
+  DALI_TEST_EQUALS( actor.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+  application.GetScene().Add( actor );
+  bool signalCalled = false;
+  LayoutDirectionFunctor layoutDirectionFunctor(signalCalled);
+
+  actor.ConnectSignal( &application, "layoutDirectionChanged", layoutDirectionFunctor );
+  DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+
+  // Test that writing the same value doesn't send a signal
+  actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
+  DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+
+  // Test that writing a different value sends the signal
+  signalCalled = false;
+  actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
+  DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
+
+  signalCalled = false;
+  actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
+  DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+
+  END_TEST;
+}
+
+struct ChildAddedSignalCheck
+{
+  ChildAddedSignalCheck( bool& signalReceived, Actor& childHandle )
+  : mSignalReceived( signalReceived ),
+    mChildHandle( childHandle )
+  {
+  }
+
+  void operator() ( Actor childHandle )
+  {
+    mSignalReceived = true;
+    mChildHandle = childHandle;
+  }
+  void operator() ()
+  {
+    mSignalReceived = true;
+    mChildHandle = Actor();
+  }
+
+  bool& mSignalReceived;
+  Actor& mChildHandle;
+};
+
+int UtcDaliChildAddedSignalP1(void)
+{
+  TestApplication application;
+  auto stage = application.GetScene();
+
+  bool signalReceived=false;
+  Actor childActor;
+
+  ChildAddedSignalCheck signal( signalReceived, childActor );
+  DevelActor::ChildAddedSignal( stage.GetRootLayer() ).Connect( &application, signal );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+  auto actorA = Actor::New();
+  stage.Add( actorA );
+  DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
+  signalReceived = false;
+
+  auto actorB = Actor::New();
+  stage.Add( actorB );
+  DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( childActor, actorB, TEST_LOCATION );
+
+  END_TEST;
+}
+
+
+int UtcDaliChildAddedSignalP2(void)
+{
+  TestApplication application;
+  auto stage = application.GetScene();
+
+  bool signalReceived=false;
+  Actor childActor;
+
+  ChildAddedSignalCheck signal( signalReceived, childActor );
+  tet_infoline( "Connect to childAdded signal by name" );
+
+  stage.GetRootLayer().ConnectSignal( &application, "childAdded", signal );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+  auto actorA = Actor::New();
+  stage.Add( actorA );
+  DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+
+  // Can't test which actor was added; signal signature is void() when connecting via name.
+  signalReceived = false;
+
+  auto actorB = Actor::New();
+  stage.Add( actorB );
+  DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliChildAddedSignalN(void)
+{
+  TestApplication application;
+  auto stage = application.GetScene();
+
+  bool signalReceived=false;
+  Actor childActor;
+
+  ChildAddedSignalCheck signal( signalReceived, childActor );
+  DevelActor::ChildAddedSignal( stage.GetRootLayer() ).Connect( &application, signal );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+  auto actorA = Actor::New();
+  stage.Add( actorA );
+  DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
+  signalReceived = false;
+
+  auto actorB = Actor::New();
+  actorA.Add( actorB );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+  END_TEST;
+}
+
+
+struct ChildRemovedSignalCheck
+{
+  ChildRemovedSignalCheck( bool& signalReceived, Actor& childHandle )
+  : mSignalReceived( signalReceived ),
+    mChildHandle( childHandle )
+  {
+  }
+
+  void operator() ( Actor childHandle )
+  {
+    mSignalReceived = true;
+    mChildHandle = childHandle;
+  }
+
+  void operator() ()
+  {
+    mSignalReceived = true;
+  }
+
+  bool& mSignalReceived;
+  Actor& mChildHandle;
+};
+
+int UtcDaliChildRemovedSignalP1(void)
+{
+  TestApplication application;
+  auto stage = application.GetScene();
+
+  bool signalReceived=false;
+  Actor childActor;
+
+  ChildRemovedSignalCheck signal( signalReceived, childActor );
+  DevelActor::ChildRemovedSignal( stage.GetRootLayer() ).Connect( &application, signal );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+  auto actorA = Actor::New();
+  stage.Add( actorA );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+  DALI_TEST_CHECK( !childActor );
+
+  stage.Remove( actorA );
+  DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
+  DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+
+  signalReceived = false;
+  auto actorB = Actor::New();
+  stage.Add( actorB );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+  stage.Remove( actorB );
+  DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( childActor, actorB, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliChildRemovedSignalP2(void)
+{
+  TestApplication application;
+  auto stage = application.GetScene();
+
+  bool signalReceived=false;
+  Actor childActor;
+
+  ChildAddedSignalCheck signal( signalReceived, childActor );
+  tet_infoline( "Connect to childRemoved signal by name" );
+
+  stage.GetRootLayer().ConnectSignal( &application, "childRemoved", signal );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+  auto actorA = Actor::New();
+  stage.Add( actorA );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+  stage.Remove( actorA );
+  DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+
+  signalReceived = false;
+  auto actorB = Actor::New();
+  stage.Add( actorB );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+  stage.Remove( actorB );
+  DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+
+  END_TEST;
+}
+
+
+int UtcDaliChildRemovedSignalN(void)
+{
+  TestApplication application;
+  auto stage = application.GetScene();
+
+  bool signalReceived=false;
+  Actor childActor;
+
+  ChildRemovedSignalCheck signal( signalReceived, childActor );
+  DevelActor::ChildRemovedSignal( stage.GetRootLayer() ).Connect( &application, signal );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+
+  auto actorA = Actor::New();
+  stage.Add( actorA );
+
+  auto actorB = Actor::New();
+  actorA.Add( actorB );
+
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+  DALI_TEST_CHECK( ! childActor );
+
+  actorA.Remove( actorB );
+  DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+  END_TEST;
+}
+
+
+int UtcDaliChildMovedSignalP(void)
+{
+  TestApplication application;
+  auto stage = application.GetScene();
+
+  bool addedASignalReceived   = false;
+  bool removedASignalReceived = false;
+  bool addedBSignalReceived   = false;
+  bool removedBSignalReceived = false;
+  Actor childActor;
+
+  auto actorA = Actor::New();
+  auto actorB = Actor::New();
+  stage.Add( actorA );
+  stage.Add( actorB );
+
+  ChildAddedSignalCheck addedSignalA( addedASignalReceived, childActor );
+  ChildRemovedSignalCheck removedSignalA( removedASignalReceived, childActor );
+  ChildAddedSignalCheck addedSignalB( addedBSignalReceived, childActor );
+  ChildRemovedSignalCheck removedSignalB( removedBSignalReceived, childActor );
+
+  DevelActor::ChildAddedSignal( actorA ).Connect( &application, addedSignalA );
+  DevelActor::ChildRemovedSignal( actorA ).Connect( &application, removedSignalA );
+  DevelActor::ChildAddedSignal( actorB ).Connect( &application, addedSignalB );
+  DevelActor::ChildRemovedSignal( actorB ).Connect( &application, removedSignalB );
+
+  DALI_TEST_EQUALS( addedASignalReceived, false, TEST_LOCATION );
+  DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
+  DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
+  DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
+
+  // Create a child of A
+
+  auto child = Actor::New();
+  actorA.Add( child );
+
+  DALI_TEST_EQUALS( addedASignalReceived, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
+  DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
+  DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
+  DALI_TEST_EQUALS( childActor, child, TEST_LOCATION );
+
+  // Move child to B:
+  addedASignalReceived   = false;
+  addedBSignalReceived   = false;
+  removedASignalReceived = false;
+  removedBSignalReceived = false;
+
+  actorB.Add( child ); // Expect this child to be re-parented
+  DALI_TEST_EQUALS( addedASignalReceived, false, TEST_LOCATION );
+  DALI_TEST_EQUALS( removedASignalReceived, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( addedBSignalReceived, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
+
+  // Move child back to A:
+  addedASignalReceived   = false;
+  addedBSignalReceived   = false;
+  removedASignalReceived = false;
+  removedBSignalReceived = false;
+
+  actorA.Add( child ); // Expect this child to be re-parented
+  DALI_TEST_EQUALS( addedASignalReceived, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
+  DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
+  DALI_TEST_EQUALS( removedBSignalReceived, true, TEST_LOCATION );
+
+
+  END_TEST;
+}
+
+int utcDaliActorCulled(void)
+{
+  TestApplication application;
+  auto stage = application.GetScene();
+
+  tet_infoline( "Check that the actor is culled if the actor is out of the screen" );
+
+  Actor actor = Actor::New();
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 10.0f ) );
+
+  Geometry geometry = CreateQuadGeometry();
+  Shader shader = CreateShader();
+  Renderer renderer = Renderer::New(geometry, shader);
+  actor.AddRenderer( renderer );
+
+  stage.Add( actor );
+
+  application.SendNotification();
+  application.Render( 0 );
+
+  DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::CULLED ), false, TEST_LOCATION );
+
+  PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::CULLED, LessThanCondition( 0.5f ) );
+  notification.SetNotifyMode( PropertyNotification::NOTIFY_ON_CHANGED );
+
+  // Connect NotifySignal
+  bool propertyNotificationSignal( false );
+  PropertyNotification source;
+  CulledPropertyNotificationFunctor f( propertyNotificationSignal, source );
+  notification.NotifySignal().Connect( &application, f ) ;
+
+  actor.SetProperty( Actor::Property::POSITION, Vector2( 1000.0f, 1000.0f ));
+
+  application.SendNotification();
+  application.Render();
+
+  application.SendNotification();
+
+  DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::CULLED ), true, TEST_LOCATION );
+
+  DALI_TEST_EQUALS( propertyNotificationSignal, true, TEST_LOCATION );
+  DALI_TEST_EQUALS( source.GetTargetProperty(), static_cast< int >( Actor::Property::CULLED ), TEST_LOCATION );
+  DALI_TEST_EQUALS( source.GetTarget().GetProperty< bool >( source.GetTargetProperty() ), true, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliEnsureRenderWhenRemovingLastRenderableActor(void)
+{
+  TestApplication application;
+  auto stage = application.GetScene();
+
+  tet_infoline( "Ensure we clear the screen when the last actor is removed" );
+
+  Actor actor = CreateRenderableActor();
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+  stage.Add( actor );
+
+  application.SendNotification();
+  application.Render();
+
+  auto& glAbstraction = application.GetGlAbstraction();
+  const auto clearCountBefore = glAbstraction.GetClearCountCalled();
+
+  actor.Unparent();
+
+  application.SendNotification();
+  application.Render();
+
+  DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliEnsureRenderWhenMakingLastActorInvisible(void)
+{
+  TestApplication application;
+  auto stage = application.GetScene();
+
+  tet_infoline( "Ensure we clear the screen when the last actor is made invisible" );
+
+  Actor actor = CreateRenderableActor();
+  actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+  stage.Add( actor );
+
+  application.SendNotification();
+  application.Render();
+
+  auto& glAbstraction = application.GetGlAbstraction();
+  const auto clearCountBefore = glAbstraction.GetClearCountCalled();
+
+  actor.SetProperty( Actor::Property::VISIBLE, false );
+
+  application.SendNotification();
+  application.Render();
+
+  DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliActorGetSizeAfterAnimation(void)
+{
+  TestApplication application;
+  tet_infoline( "Check the actor size before / after an animation is finished" );
+
+  Vector3 actorSize( 100.0f, 100.0f, 0.0f );
+
+  Actor actor = Actor::New();
+  actor.SetProperty( Actor::Property::SIZE, actorSize );
+  actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
+  application.GetScene().Add( actor );
+
+  // Size should be updated without rendering.
+  Vector3 size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render();
+
+  // Size and current size should be updated.
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( actorSize.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actorSize.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actorSize.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  Vector3 currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( actorSize.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actorSize.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( actorSize.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  // Set size again
+  actorSize = Vector3( 200.0f, 200.0f, 0.0f );
+  actor.SetProperty( Actor::Property::SIZE, actorSize );
+
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  Vector3 targetValue( 10.0f, 20.0f, 0.0f );
+
+  Animation animation = Animation::New( 1.0f );
+  animation.AnimateTo( Property( actor, Actor::Property::SIZE ), targetValue );
+  animation.Play();
+
+  // Size should be updated without rendering.
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render( 1100 ); // After the animation
+
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  targetValue.width = 50.0f;
+
+  animation.Clear();
+  animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetValue.width );
+  animation.Play();
+
+  application.SendNotification();
+  application.Render( 1100 ); // After the animation
+
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  targetValue.height = 70.0f;
+
+  animation.Clear();
+  animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetValue.height );
+  animation.Play();
+
+  application.SendNotification();
+  application.Render( 1100 ); // After the animation
+
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  Vector3 offset( 10.0f, 20.0f, 0.0f );
+
+  animation.Clear();
+  animation.AnimateBy( Property( actor, Actor::Property::SIZE ), offset );
+  animation.Play();
+
+  application.SendNotification();
+  application.Render( 1100 ); // After the animation
+
+  targetValue += offset;
+
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  offset.width = 20.0f;
+
+  animation.Clear();
+  animation.AnimateBy( Property( actor, Actor::Property::SIZE_WIDTH ), offset.width );
+  animation.Play();
+
+  application.SendNotification();
+  application.Render( 1100 ); // After the animation
+
+  targetValue.width += offset.width;
+
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  offset.height = 10.0f;
+
+  animation.Clear();
+  animation.AnimateBy( Property( actor, Actor::Property::SIZE_HEIGHT ), offset.height );
+  animation.Play();
+
+  application.SendNotification();
+  application.Render( 1100 ); // After the animation
+
+  targetValue.height += offset.height;
+
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
+  DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+
+  // Set size again
+  actorSize = Vector3( 300.0f, 300.0f, 0.0f );
+
+  actor.SetProperty( Actor::Property::SIZE, actorSize );
+
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  application.SendNotification();
+  application.Render();
+
+  size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
+  DALI_TEST_EQUALS( currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int utcDaliActorPartialUpdate(void)
+{
+  TestApplication application(
+    TestApplication::DEFAULT_SURFACE_WIDTH,
+    TestApplication::DEFAULT_SURFACE_HEIGHT,
+    TestApplication::DEFAULT_HORIZONTAL_DPI,
+    TestApplication::DEFAULT_VERTICAL_DPI,
+    true,
+    true);
+
+  tet_infoline("Check the damaged area");
+
+  const TestGlAbstraction::ScissorParams& glScissorParams( application.GetGlAbstraction().GetScissorParams() );
+
+  std::vector<Rect<int>> damagedRects;
+  Rect<int> clippingRect;
+  application.SendNotification();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+
+  // First render pass, nothing to render, adaptor would just do swap buffer.
+  DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+  Actor actor = CreateRenderableActor();
+  actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
+  actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
+  actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+  application.GetScene().Add(actor);
+
+  application.SendNotification();
+
+  // 1. Actor added, damaged rect is added size of actor
+  damagedRects.clear();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+  DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+  // Aligned by 16
+  clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
+  DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  // 2. Set new size
+  actor.SetProperty(Actor::Property::SIZE, Vector3(32.0f, 32.0f, 0));
+  application.SendNotification();
+
+  damagedRects.clear();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+  DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+  // Aligned by 16
+  clippingRect = Rect<int>(16, 752, 48, 48); // in screen coordinates, includes 3 last frames updates
+  DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  // 3. Set new position
+  actor.SetProperty(Actor::Property::POSITION, Vector3(32.0f, 32.0f, 0));
+  application.SendNotification();
+
+  damagedRects.clear();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+  DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+  // Aligned by 16
+  clippingRect = Rect<int>(16, 736, 64, 64); // in screen coordinates, includes 3 last frames updates
+  DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  application.GetScene().Remove(actor);
+  application.SendNotification();
+
+  // Actor removed, last 3 dirty rects are reported. Adaptor would merge them together.
+  damagedRects.clear();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+  DALI_TEST_EQUALS(damagedRects.size(), 3, TEST_LOCATION);
+
+  clippingRect = damagedRects[0];
+  clippingRect.Merge(damagedRects[1]);
+  clippingRect.Merge(damagedRects[2]);
+
+  DALI_TEST_EQUALS(clippingRect.IsEmpty(), false, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.IsValid(), true, TEST_LOCATION);
+  DALI_TEST_EQUALS<Rect<int>>(clippingRect, Rect<int>(16, 736, 64, 64), TEST_LOCATION);
+
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  END_TEST;
+}
+
+int utcDaliActorPartialUpdateSetColor(void)
+{
+  TestApplication application(
+    TestApplication::DEFAULT_SURFACE_WIDTH,
+    TestApplication::DEFAULT_SURFACE_HEIGHT,
+    TestApplication::DEFAULT_HORIZONTAL_DPI,
+    TestApplication::DEFAULT_VERTICAL_DPI,
+    true,
+    true);
+
+  tet_infoline("Check uniform update");
+
+  const TestGlAbstraction::ScissorParams& glScissorParams( application.GetGlAbstraction().GetScissorParams() );
+
+  std::vector<Rect<int>> damagedRects;
+  Rect<int> clippingRect;
+  application.SendNotification();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+
+  // First render pass, nothing to render, adaptor would just do swap buffer.
+  DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+  Actor actor = CreateRenderableActor();
+  actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
+  actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
+  actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+  application.GetScene().Add(actor);
+
+  application.SendNotification();
+
+  // 1. Actor added, damaged rect is added size of actor
+  damagedRects.clear();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+  DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+  // Aligned by 16
+  clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
+  DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  damagedRects.clear();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+
+  damagedRects.clear();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+
+  // 2. Set new color
+  actor.SetProperty(Actor::Property::COLOR, Vector3(1.0f, 0.0f, 0.0f));
+  application.SendNotification();
+
+  damagedRects.clear();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+  DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+  // Aligned by 16
+  clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
+  DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  END_TEST;
+}
+
+const std::string SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME("uLightCameraProjectionMatrix");
+const std::string SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME("uLightCameraViewMatrix");
+const std::string SHADER_SHADOW_COLOR_PROPERTY_NAME("uShadowColor");
+const char* const RENDER_SHADOW_VERTEX_SOURCE =
+  " uniform mediump mat4 uLightCameraProjectionMatrix;\n"
+  " uniform mediump mat4 uLightCameraViewMatrix;\n"
+  "\n"
+  "void main()\n"
+  "{\n"
+  "  gl_Position = uProjection * uModelView * vec4(aPosition,1.0);\n"
+  "  vec4 textureCoords = uLightCameraProjectionMatrix * uLightCameraViewMatrix * uModelMatrix  * vec4(aPosition,1.0);\n"
+  "  vTexCoord = 0.5 + 0.5 * (textureCoords.xy/textureCoords.w);\n"
+  "}\n";
+
+const char* const RENDER_SHADOW_FRAGMENT_SOURCE =
+  "uniform lowp vec4 uShadowColor;\n"
+  "void main()\n"
+  "{\n"
+  "  lowp float alpha;\n"
+  "  alpha = texture2D(sTexture, vec2(vTexCoord.x, vTexCoord.y)).a;\n"
+  "  gl_FragColor = vec4(uShadowColor.rgb, uShadowColor.a * alpha);\n"
+  "}\n";
+
+int utcDaliActorPartialUpdateSetProperty(void)
+{
+  TestApplication application(
+    TestApplication::DEFAULT_SURFACE_WIDTH,
+    TestApplication::DEFAULT_SURFACE_HEIGHT,
+    TestApplication::DEFAULT_HORIZONTAL_DPI,
+    TestApplication::DEFAULT_VERTICAL_DPI,
+    true,
+    true);
+
+  tet_infoline( "Set/Update property with partial update" );
+
+  const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
+
+  std::vector<Rect<int>> damagedRects;
+  Rect<int> clippingRect;
+  application.SendNotification();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+
+  // First render pass, nothing to render, adaptor would just do swap buffer.
+  DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+  Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 4u, 4u);
+  Actor actor = CreateRenderableActor(image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE);
+  actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
+  actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
+  actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+  application.GetScene().Add(actor);
+
+  actor.RegisterProperty(SHADER_SHADOW_COLOR_PROPERTY_NAME, Vector4(1.0f, 0.0f, 0.0f, 1.0f));
+
+  damagedRects.clear();
+  application.SendNotification();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+  DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+  // Aligned by 16
+  clippingRect = Rect<int>(16, 768, 32, 32); // in screen coordinates, includes 3 last frames updates
+  DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  Property::Index shadowColorPropertyIndex = actor.GetPropertyIndex( SHADER_SHADOW_COLOR_PROPERTY_NAME );
+  actor.SetProperty(shadowColorPropertyIndex, Vector4(1.0f, 1.0f, 0.0f, 1.0f));
+
+  damagedRects.clear();
+  application.SendNotification();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+  DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+  DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  damagedRects.clear();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+  DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+  DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  damagedRects.clear();
+  application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
+  DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
+
+  END_TEST;
+}
+
+int utcDaliActorPartialUpdateTwoActors(void)
+{
+  TestApplication application(
+    TestApplication::DEFAULT_SURFACE_WIDTH,
+    TestApplication::DEFAULT_SURFACE_HEIGHT,
+    TestApplication::DEFAULT_HORIZONTAL_DPI,
+    TestApplication::DEFAULT_VERTICAL_DPI,
+    true,
+    true);
+
+  tet_infoline("Check the damaged rects with partial update and two actors");
+
+  const TestGlAbstraction::ScissorParams& glScissorParams( application.GetGlAbstraction().GetScissorParams() );
+
+  Actor actor = CreateRenderableActor();
+  actor.SetProperty(Actor::Property::POSITION, Vector3(100.0f, 100.0f, 0.0f));
+  actor.SetProperty(Actor::Property::SIZE, Vector3(50.0f, 50.0f, 0.0f));
+  actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+  application.GetScene().Add(actor);
+
+  Actor actor2 = CreateRenderableActor();
+  actor2.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 150.0f, 0.0f));
+  actor2.SetProperty(Actor::Property::SIZE, Vector3(100.0f, 100.0f, 0.0f));
+  actor2.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+  application.GetScene().Add(actor2);
+
+  application.SendNotification();
+  std::vector<Rect<int>> damagedRects;
+  application.PreRenderWithPartialUpdate(TestApplication::DEFAULT_RENDER_INTERVAL, nullptr, damagedRects);
+
+  DALI_TEST_EQUALS(damagedRects.size(), 2, TEST_LOCATION);
+  DALI_TEST_EQUALS<Rect<int>>(Rect<int>(64, 672, 64, 64), damagedRects[0], TEST_LOCATION);
+  DALI_TEST_EQUALS<Rect<int>>(Rect<int>(96, 592, 112, 112), damagedRects[1], TEST_LOCATION);
+
+  // in screen coordinates, adaptor would calculate it using previous frames information
+  Rect<int> clippingRect = Rect<int>(64, 592, 144, 192);
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  END_TEST;
+}
+
+int utcDaliActorPartialUpdateActorsWithSizeHint(void)
+{
+  TestApplication application(
+    TestApplication::DEFAULT_SURFACE_WIDTH,
+    TestApplication::DEFAULT_SURFACE_HEIGHT,
+    TestApplication::DEFAULT_HORIZONTAL_DPI,
+    TestApplication::DEFAULT_VERTICAL_DPI,
+    true,
+    true);
+
+  tet_infoline( "Check the damaged rect with partial update and actor size hint" );
+
+  const TestGlAbstraction::ScissorParams& glScissorParams( application.GetGlAbstraction().GetScissorParams() );
+
+  Actor actor = CreateRenderableActor();
+  actor.SetProperty(Actor::Property::POSITION, Vector3(75.0f, 150.0f, 0.0f));
+  actor.SetProperty(Actor::Property::SIZE, Vector3(75.0f, 150.0f, 0.0f));
+  actor.SetProperty(DevelActor::Property::UPDATE_SIZE_HINT, Vector3(150, 300, 0));
+  actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+  application.GetScene().Add(actor);
+
+  application.SendNotification();
+  std::vector<Rect<int>> damagedRects;
+  application.PreRenderWithPartialUpdate(TestApplication::DEFAULT_RENDER_INTERVAL, nullptr, damagedRects);
+
+  DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
+
+  Rect<int> clippingRect = Rect<int>(0, 496, 160, 320);
+  DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
+
+  application.RenderWithPartialUpdate(damagedRects, clippingRect);
+
+  DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
+  DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
+
+  END_TEST;
+}
+
+int UtcDaliActorCaptureAllTouchAfterStartPropertyP(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+  DALI_TEST_EQUALS(actor.GetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START).Get<bool>(), false, TEST_LOCATION);
+  actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, true);
+  DALI_TEST_EQUALS(actor.GetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START).Get<bool>(), true, TEST_LOCATION);
+  DALI_TEST_EQUALS(actor.GetPropertyType(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), Property::BOOLEAN, TEST_LOCATION);
+  DALI_TEST_EQUALS(actor.IsPropertyWritable(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), true, TEST_LOCATION);
+  DALI_TEST_EQUALS(actor.IsPropertyAnimatable(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), false, TEST_LOCATION);
+  DALI_TEST_EQUALS(actor.IsPropertyAConstraintInput(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), false, TEST_LOCATION);
+  DALI_TEST_EQUALS(actor.GetPropertyName(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START), "captureAllTouchAfterStart", TEST_LOCATION);
+  END_TEST;
+}
+
+int UtcDaliActorCaptureAllTouchAfterStartPropertyN(void)
+{
+  TestApplication application;
+
+  Actor actor = Actor::New();
+
+  // Make sure setting invalid types does not cause a crash
+  try
+  {
+    actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, 1.0f);
+    actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector2::ONE);
+    actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector3::ONE);
+    actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Vector4::ONE);
+    actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Property::Map());
+    actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, Property::Array());
+    tet_result(TET_PASS);
+  }
+  catch(...)
+  {
+     tet_result(TET_FAIL);
+  }
+  END_TEST;
+}
+
+int UtcDaliActorLowerBelowNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Actor arg1;
+    instance.LowerBelow(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorRaiseAboveNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Actor arg1;
+    instance.RaiseAbove(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorRaiseToTopNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.RaiseToTop();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorAddRendererNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Renderer arg1;
+    instance.AddRenderer(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorTouchedSignalNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.TouchedSignal();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorTranslateByNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Vector3 arg1;
+    instance.TranslateBy(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorFindChildByIdNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    unsigned int arg1 = 0u;
+    instance.FindChildById(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetRendererAtNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    unsigned int arg1 = 0u;
+    instance.GetRendererAt(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorHoveredSignalNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.HoveredSignal();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorLowerToBottomNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.LowerToBottom();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorOnSceneSignalNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.OnSceneSignal();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorOffSceneSignalNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.OffSceneSignal();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorRemoveRendererNegative01(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    unsigned int arg1 = 0u;
+    instance.RemoveRenderer(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorRemoveRendererNegative02(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Renderer arg1;
+    instance.RemoveRenderer(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorFindChildByNameNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    std::string arg1;
+    instance.FindChildByName(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorSetResizePolicyNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::ResizePolicy::Type arg1 = ResizePolicy::USE_NATURAL_SIZE;
+    Dali::Dimension::Type arg2 = Dimension::ALL_DIMENSIONS;
+    instance.SetResizePolicy(arg1,arg2);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorOnRelayoutSignalNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.OnRelayoutSignal();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorWheelEventSignalNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.WheelEventSignal();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetHeightForWidthNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    float arg1 = 0.0f;
+    instance.GetHeightForWidth(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetWidthForHeightNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    float arg1 = 0.0f;
+    instance.GetWidthForHeight(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorLayoutDirectionChangedSignalNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.LayoutDirectionChangedSignal();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorAddNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Actor arg1;
+    instance.Add(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorLowerNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.Lower();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorRaiseNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.Raise();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorRemoveNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Actor arg1;
+    instance.Remove(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorScaleByNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Vector3 arg1;
+    instance.ScaleBy(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetLayerNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.GetLayer();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorRotateByNegative01(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Quaternion arg1;
+    instance.RotateBy(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorRotateByNegative02(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Radian arg1;
+    Dali::Vector3 arg2;
+    instance.RotateBy(arg1,arg2);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorUnparentNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.Unparent();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetChildAtNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    unsigned int arg1 = 0u;
+    instance.GetChildAt(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetChildCountNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.GetChildCount();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetTargetSizeNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.GetTargetSize();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorScreenToLocalNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    float arg1 = 0.0f;
+    float arg2 = 0.0f;
+    float arg3 = 0.0f;
+    float arg4 = 0.0f;
+    instance.ScreenToLocal(arg1,arg2,arg3,arg4);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetNaturalSizeNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.GetNaturalSize();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetRelayoutSizeNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Dimension::Type arg1 = Dimension::HEIGHT;
+    instance.GetRelayoutSize(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetResizePolicyNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    Dali::Dimension::Type arg1 = Dimension::ALL_DIMENSIONS;
+    instance.GetResizePolicy(arg1);
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetRendererCountNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.GetRendererCount();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}
+
+int UtcDaliActorGetParentNegative(void)
+{
+  TestApplication application;
+  Dali::Actor instance;
+  try
+  {
+    instance.GetParent();
+    DALI_TEST_CHECK(false); // Should not get here
+  }
+  catch(...)
+  {
+    DALI_TEST_CHECK(true); // We expect an assert
+  }
+  END_TEST;
+}