Revert "If the currently focused actor is hidden, it should lose focus. and If VISIBL...

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

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-KeyboardFocusManager.cpp b/automated-tests/src/dali-toolkit/utc-Dali-KeyboardFocusManager.cpp
old mode 100755 (executable)
new mode 100644 (file)
index 1b82c49..60e9eea
--- a/automated-tests/src/dali-toolkit/utc-Dali-KeyboardFocusManager.cpp
+++ b/automated-tests/src/dali-toolkit/utc-Dali-KeyboardFocusManager.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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,17 +15,20 @@
  *
  */
 
-#include <iostream>
 #include <stdlib.h>
+#include <iostream>
 
 // Need to override adaptor classes for toolkit test harness, so include
 // test harness headers before dali headers.
 #include <dali-toolkit-test-suite-utils.h>
-
 #include <dali-toolkit/dali-toolkit.h>
-#include <dali/integration-api/events/key-event-integ.h>
-#include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 #include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/devel-api/controls/table-view/table-view.h>
+#include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
+#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/integration-api/events/key-event-integ.h>
+#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/integration-api/events/wheel-event-integ.h>
 
 using namespace Dali;
 using namespace Dali::Toolkit;
@@ -40,10 +43,8 @@ void utc_dali_toolkit_keyboard_focus_manager_cleanup(void)
   test_return_value = TET_PASS;
 }
 
-
 namespace
 {
-
 const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
 
 // Functors to test whether GetNextFocusableActor() method of CustomAlgorithmInterface is called when the keyboard focus is about to change
@@ -54,35 +55,39 @@ public:
   : mInterfaceVerified(interfaceVerified),
     mCurrentFocusedActor(),
     mProposedActorToFocus(),
-    mDirection(Control::KeyboardFocus::LEFT)
+    mDirection(Control::KeyboardFocus::LEFT),
+    mDeviceName("")
   {
   }
 
-  Actor GetNextFocusableActor(Actor currentFocusedActor, Actor proposedActorToFocus, Control::KeyboardFocus::Direction direction)
+  Actor GetNextFocusableActor(Actor currentFocusedActor, Actor proposedActorToFocus, Control::KeyboardFocus::Direction direction, const std::string& deviceName)
   {
     tet_infoline("Verifying CustomAlgorithm()");
 
     mInterfaceVerified = true;
 
-    mCurrentFocusedActor = currentFocusedActor;
+    mCurrentFocusedActor  = currentFocusedActor;
     mProposedActorToFocus = proposedActorToFocus;
-    mDirection = direction;
+    mDirection            = direction;
+    mDeviceName           = deviceName;
 
     return mProposedActorToFocus;
   }
 
   void Reset()
   {
-    mInterfaceVerified = false;
-    mCurrentFocusedActor = Actor();
+    mInterfaceVerified    = false;
+    mCurrentFocusedActor  = Actor();
     mProposedActorToFocus = Actor();
-    mDirection = Control::KeyboardFocus::LEFT;
+    mDirection            = Control::KeyboardFocus::LEFT;
+    mDeviceName           = "";
   }
 
-  bool& mInterfaceVerified;
-  Actor mCurrentFocusedActor;
-  Actor mProposedActorToFocus;
+  bool&                             mInterfaceVerified;
+  Actor                             mCurrentFocusedActor;
+  Actor                             mProposedActorToFocus;
   Control::KeyboardFocus::Direction mDirection;
+  std::string mDeviceName;
 };
 
 // Functors to test whether PreFocusChange signal is emitted when the keyboard focus is about to change
@@ -103,24 +108,24 @@ public:
 
     mSignalVerified = true;
 
-    mCurrentFocusedActor = currentFocusedActor;
+    mCurrentFocusedActor  = currentFocusedActor;
     mProposedActorToFocus = proposedActorToFocus;
-    mDirection = direction;
+    mDirection            = direction;
 
     return mProposedActorToFocus;
   }
 
   void Reset()
   {
-    mSignalVerified = false;
-    mCurrentFocusedActor = Actor();
+    mSignalVerified       = false;
+    mCurrentFocusedActor  = Actor();
     mProposedActorToFocus = Actor();
-    mDirection = Control::KeyboardFocus::LEFT;
+    mDirection            = Control::KeyboardFocus::LEFT;
   }
 
-  bool& mSignalVerified;
-  Actor mCurrentFocusedActor;
-  Actor mProposedActorToFocus;
+  bool&                             mSignalVerified;
+  Actor                             mCurrentFocusedActor;
+  Actor                             mProposedActorToFocus;
   Control::KeyboardFocus::Direction mDirection;
 };
 
@@ -145,7 +150,7 @@ public:
     }
 
     mOriginalFocusedActor = originalFocusedActor;
-    mCurrentFocusedActor = currentFocusedActor;
+    mCurrentFocusedActor  = currentFocusedActor;
   }
 
   void Reset()
@@ -176,7 +181,7 @@ public:
     mSignalVerified = true;
 
     mCurrentFocusedActor = currentFocusedActor;
-    mForward = forward;
+    mForward             = forward;
   }
 
   void Reset()
@@ -186,7 +191,7 @@ public:
 
   bool& mSignalVerified;
   Actor mCurrentFocusedActor;
-  bool mForward;
+  bool  mForward;
 };
 
 // Functors to test whether focused actor activated signal is emitted when the focused actor is activated
@@ -217,6 +222,62 @@ public:
   Actor mActivatedActor;
 };
 
+class KeyEventCallback : public Dali::ConnectionTracker
+{
+public:
+  /**
+   * Constructor
+   * @param[in]  returnValue  Set return value of KeyEvent callback.
+   * */
+  KeyEventCallback(bool consumed)
+  : mConsumed(consumed),
+    mIsCalled(false)
+  {
+  }
+
+  bool Callback(Control control, const KeyEvent& keyEvent)
+  {
+    mIsCalled = true;
+    return mConsumed;
+  }
+
+  void Callback(const KeyEvent& keyEvent)
+  {
+    mIsCalled = true;
+  }
+
+  bool mConsumed;
+  bool mIsCalled;
+};
+
+class WheelEventCallback : public Dali::ConnectionTracker
+{
+public:
+  /**
+   * Constructor
+   * @param[in]  returnValue  Set return value of WheelEvent callback.
+   * */
+  WheelEventCallback(bool consumed)
+  : mConsumed(consumed),
+    mIsCalled(false)
+  {
+  }
+
+  bool Callback(Actor actor, const WheelEvent& wheelEvent)
+  {
+    mIsCalled = true;
+    return mConsumed;
+  }
+
+  void Callback(const WheelEvent& wheelEvent)
+  {
+    mIsCalled = true;
+  }
+
+  bool mConsumed;
+  bool mIsCalled;
+};
+
 // Used to connect to signals via the ConnectSignal Handle method
 struct CallbackFunctor
 {
@@ -239,10 +300,10 @@ int UtcDaliKeyboardFocusManagerGet(void)
 
   // Register Type
   TypeInfo type;
-  type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
-  DALI_TEST_CHECK( type );
+  type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+  DALI_TEST_CHECK(type);
   BaseHandle handle = type.CreateInstance();
-  DALI_TEST_CHECK( handle );
+  DALI_TEST_CHECK(handle);
 
   KeyboardFocusManager manager;
 
@@ -268,13 +329,13 @@ int UtcDaliKeyboardFocusManagerSetAndGetCurrentFocusActor(void)
 
   // Create the first actor and add it to the stage
   Actor first = Actor::New();
-  first.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(first);
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(first);
 
   // Create the second actor and add it to the stage
   Actor second = Actor::New();
-  second.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(second);
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(second);
 
   // Create the third actor but don't add it to the stage
   Actor third = Actor::New();
@@ -298,14 +359,14 @@ int UtcDaliKeyboardFocusManagerSetAndGetCurrentFocusActor(void)
   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
 
   // Add the third actor to the stage
-  Stage::GetCurrent().Add(third);
+  application.GetScene().Add(third);
 
   // Check that it will fail to set focus on the third actor as it's not focusable
   DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == false);
   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
 
   // Make the third actor focusable
-  third.SetKeyboardFocusable(true);
+  third.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 
   // Check that the focus is successfully moved to the third actor
   DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == true);
@@ -321,31 +382,31 @@ int UtcDaliKeyboardFocusManagerMoveFocus(void)
 
   // Register Type
   TypeInfo type;
-  type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
-  DALI_TEST_CHECK( type );
+  type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+  DALI_TEST_CHECK(type);
   BaseHandle handle = type.CreateInstance();
-  DALI_TEST_CHECK( handle );
+  DALI_TEST_CHECK(handle);
 
   KeyboardFocusManager manager = KeyboardFocusManager::Get();
   DALI_TEST_CHECK(manager);
 
-  bool preFocusChangeSignalVerified = false;
+  bool                   preFocusChangeSignalVerified = false;
   PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
-  manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+  manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
 
-  bool focusChangedSignalVerified = false;
+  bool                 focusChangedSignalVerified = false;
   FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
-  manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+  manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
 
   // Create the first actor and add it to the stage
   Actor first = Actor::New();
-  first.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(first);
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(first);
 
   // Create the second actor and add it to the stage
   Actor second = Actor::New();
-  second.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(second);
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(second);
 
   // Move the focus to the right
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
@@ -395,16 +456,16 @@ int UtcDaliKeyboardFocusManagerMoveFocus(void)
   DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
 
   // Create a 2x2 table view and try to move focus inside it
-  TableView tableView = TableView::New( 2, 2 );
-  Stage::GetCurrent().Add(tableView);
+  TableView tableView = TableView::New(2, 2);
+  application.GetScene().Add(tableView);
 
   // Create the third actor
   Actor third = Actor::New();
-  third.SetKeyboardFocusable(true);
+  third.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 
   // Create the fourth actor
   Actor fourth = Actor::New();
-  fourth.SetKeyboardFocusable(true);
+  fourth.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 
   // Add the four children to table view
   tableView.AddChild(first, TableView::CellPosition(0, 0));
@@ -484,31 +545,31 @@ int UtcDaliKeyboardFocusManagerCustomAlgorithmMoveFocus(void)
 
   // Register Type
   TypeInfo type;
-  type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
-  DALI_TEST_CHECK( type );
+  type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+  DALI_TEST_CHECK(type);
   BaseHandle handle = type.CreateInstance();
-  DALI_TEST_CHECK( handle );
+  DALI_TEST_CHECK(handle);
 
   KeyboardFocusManager manager = KeyboardFocusManager::Get();
   DALI_TEST_CHECK(manager);
 
-  bool preFocusChangeSignalVerified = false;
+  bool                   preFocusChangeSignalVerified = false;
   PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
-  manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+  manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
 
-  bool focusChangedSignalVerified = false;
+  bool                 focusChangedSignalVerified = false;
   FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
-  manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+  manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
 
   // Create the first actor and add it to the stage
   Actor first = Actor::New();
-  first.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(first);
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(first);
 
   // Create the second actor and add it to the stage
   Actor second = Actor::New();
-  second.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(second);
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(second);
 
   // Move the focus to the right
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
@@ -520,18 +581,20 @@ int UtcDaliKeyboardFocusManagerCustomAlgorithmMoveFocus(void)
   DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::RIGHT);
   preFocusChangeCallback.Reset();
 
-  bool customAlgorithmInterfaceVerified = false;
+  bool            customAlgorithmInterfaceVerified = false;
+  std::string     deviceName                       = "deviceName";
   CustomAlgorithm customAlgorithm(customAlgorithmInterfaceVerified);
   Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(manager, customAlgorithm);
 
   // Move the focus towards right
-  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
+  DALI_TEST_CHECK(Toolkit::DevelKeyboardFocusManager::MoveFocus(manager, Control::KeyboardFocus::RIGHT, deviceName) == false);
 
   // Because no layout control in the stage and the first actor is focused, it should invoke CustomAlgorithm
   DALI_TEST_CHECK(customAlgorithm.mInterfaceVerified);
   DALI_TEST_CHECK(customAlgorithm.mCurrentFocusedActor == Actor());
   DALI_TEST_CHECK(customAlgorithm.mProposedActorToFocus == Actor());
   DALI_TEST_CHECK(customAlgorithm.mDirection == Control::KeyboardFocus::RIGHT);
+  DALI_TEST_EQUALS(customAlgorithm.mDeviceName, deviceName, TEST_LOCATION );
   customAlgorithm.Reset();
 
   // Check that the focus is set on the first actor
@@ -543,13 +606,14 @@ int UtcDaliKeyboardFocusManagerCustomAlgorithmMoveFocus(void)
   focusChangedCallback.Reset();
 
   // Move the focus towards right
-  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
+  DALI_TEST_CHECK(Toolkit::DevelKeyboardFocusManager::MoveFocus(manager, Control::KeyboardFocus::RIGHT, deviceName) == false);
 
   // Because no layout control in the stage and the first actor is focused, it should invoke CustomAlgorithm
   DALI_TEST_CHECK(customAlgorithm.mInterfaceVerified);
   DALI_TEST_CHECK(customAlgorithm.mCurrentFocusedActor == first);
   DALI_TEST_CHECK(customAlgorithm.mProposedActorToFocus == Actor());
   DALI_TEST_CHECK(customAlgorithm.mDirection == Control::KeyboardFocus::RIGHT);
+  DALI_TEST_EQUALS(customAlgorithm.mDeviceName, deviceName, TEST_LOCATION );
   customAlgorithm.Reset();
 
   // Check that the focus is set on the second actor
@@ -561,13 +625,14 @@ int UtcDaliKeyboardFocusManagerCustomAlgorithmMoveFocus(void)
   focusChangedCallback.Reset();
 
   // Move the focus towards up
-  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == false);
+  DALI_TEST_CHECK(Toolkit::DevelKeyboardFocusManager::MoveFocus(manager, Control::KeyboardFocus::UP, deviceName) == false);
 
   // Because no layout control in the stage and no actor is focused, it should invoke CustomAlgorithm
   DALI_TEST_CHECK(customAlgorithm.mInterfaceVerified);
   DALI_TEST_CHECK(customAlgorithm.mCurrentFocusedActor == second);
   DALI_TEST_CHECK(customAlgorithm.mProposedActorToFocus == Actor());
   DALI_TEST_CHECK(customAlgorithm.mDirection == Control::KeyboardFocus::UP);
+  DALI_TEST_EQUALS(customAlgorithm.mDeviceName, deviceName, TEST_LOCATION );
   customAlgorithm.Reset();
   DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
 
@@ -581,24 +646,24 @@ int UtcDaliKeyboardFocusManagerFocusablePropertiesMoveFocus(void)
 
   // Register Type
   TypeInfo type;
-  type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
-  DALI_TEST_CHECK( type );
+  type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+  DALI_TEST_CHECK(type);
   BaseHandle handle = type.CreateInstance();
-  DALI_TEST_CHECK( handle );
+  DALI_TEST_CHECK(handle);
 
   KeyboardFocusManager manager = KeyboardFocusManager::Get();
   DALI_TEST_CHECK(manager);
 
-  bool focusChangedSignalVerified = false;
+  bool                 focusChangedSignalVerified = false;
   FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
-  manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+  manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
 
   PushButton button1 = PushButton::New();
   PushButton button2 = PushButton::New();
-  button1.SetKeyboardFocusable(true);
-  button2.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(button1);
-  Stage::GetCurrent().Add(button2);
+  button1.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  button2.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(button1);
+  application.GetScene().Add(button2);
 
   // Set the focus to the button1
   DALI_TEST_CHECK(manager.SetCurrentFocusActor(button1) == true);
@@ -609,22 +674,26 @@ int UtcDaliKeyboardFocusManagerFocusablePropertiesMoveFocus(void)
   focusChangedCallback.Reset();
 
   // set the navigation properties of button1
-  button1.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetId()));
-  button1.SetProperty(Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetId()));
-  button1.SetProperty(Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetId()));
-  button1.SetProperty(Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetId()));
+  button1.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty<int>(Actor::Property::ID)));
+  button1.SetProperty(Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty<int>(Actor::Property::ID)));
+  button1.SetProperty(Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty<int>(Actor::Property::ID)));
+  button1.SetProperty(Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty<int>(Actor::Property::ID)));
+  button1.SetProperty(Toolkit::DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty< int >( Actor::Property::ID)));
+  button1.SetProperty(Toolkit::DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)button2.GetProperty< int >( Actor::Property::ID)));
 
   // set the navigation properties of button2
-  button2.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetId()));
-  button2.SetProperty(Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetId()));
-  button2.SetProperty(Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetId()));
-  button2.SetProperty(Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetId()));
+  button2.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty<int>(Actor::Property::ID)));
+  button2.SetProperty(Toolkit::DevelControl::Property::RIGHT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty<int>(Actor::Property::ID)));
+  button2.SetProperty(Toolkit::DevelControl::Property::UP_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty<int>(Actor::Property::ID)));
+  button2.SetProperty(Toolkit::DevelControl::Property::DOWN_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty<int>(Actor::Property::ID)));
+  button2.SetProperty(Toolkit::DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty< int >( Actor::Property::ID)));
+  button2.SetProperty(Toolkit::DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty< int >( Actor::Property::ID)));
 
   // Move the focus towards left
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
 
   // Confirm whether focus is moved to button2
-  DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+  DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
@@ -634,7 +703,7 @@ int UtcDaliKeyboardFocusManagerFocusablePropertiesMoveFocus(void)
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
 
   // Confirm whether focus is moved to button1
-  DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+  DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
@@ -644,7 +713,7 @@ int UtcDaliKeyboardFocusManagerFocusablePropertiesMoveFocus(void)
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == true);
 
   // Confirm whether focus is moved to button2
-  DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+  DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
@@ -654,6 +723,26 @@ int UtcDaliKeyboardFocusManagerFocusablePropertiesMoveFocus(void)
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::DOWN) == true);
 
   // Confirm whether focus is moved to button1
+  DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+  focusChangedCallback.Reset();
+
+  // Move the focus towards clockwise
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::CLOCKWISE) == true);
+
+  // Confirm whether focus is moved to button2
+  DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
+  focusChangedCallback.Reset();
+
+  // Move the focus towards clockwise
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::COUNTER_CLOCKWISE) == true);
+
+  // Confirm whether focus is moved to button1
   DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
@@ -661,15 +750,15 @@ int UtcDaliKeyboardFocusManagerFocusablePropertiesMoveFocus(void)
   focusChangedCallback.Reset();
 
   // Create a 1x1 table view and try to move focus inside it
-  TableView tableView = TableView::New( 1, 1 );
-  Stage::GetCurrent().Add(tableView);
+  TableView tableView = TableView::New(1, 1);
+  application.GetScene().Add(tableView);
 
   PushButton button = PushButton::New();
-  button.SetKeyboardFocusable(true);
+  button.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
   tableView.AddChild(button, TableView::CellPosition(0, 0));
 
   // set the navigation properties of button3
-  button.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetId()));
+  button.SetProperty(Toolkit::DevelControl::Property::LEFT_FOCUSABLE_ACTOR_ID, Property::Value((int)button1.GetProperty<int>(Actor::Property::ID)));
 
   // Set the focus to the button
   DALI_TEST_CHECK(manager.SetCurrentFocusActor(button) == true);
@@ -683,7 +772,7 @@ int UtcDaliKeyboardFocusManagerFocusablePropertiesMoveFocus(void)
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
 
   // Confirm whether focus is moved to button1
-  DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+  DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
@@ -703,13 +792,13 @@ int UtcDaliKeyboardFocusManagerClearFocus(void)
 
   // Create the first actor and add it to the stage
   Actor first = Actor::New();
-  first.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(first);
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(first);
 
   // Create the second actor and add it to the stage
   Actor second = Actor::New();
-  second.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(second);
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(second);
 
   // Check that the focus is set on the first actor
   DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
@@ -789,9 +878,9 @@ int UtcDaliKeyboardFocusManagerGetFocusGroup(void)
 
   // Create an actor with two child actors and add it to the stage
   Actor parent = Actor::New();
-  Actor child = Actor::New();
+  Actor child  = Actor::New();
   parent.Add(child);
-  Stage::GetCurrent().Add(parent);
+  application.GetScene().Add(parent);
 
   // Create three actors and add them as the children of the first child actor
   Actor grandChild = Actor::New();
@@ -851,7 +940,6 @@ int UtcDaliKeyboardFocusManagerSetAndGetFocusIndicator(void)
   END_TEST;
 }
 
-
 int UtcDaliKeyboardFocusManagerSignalFocusedActorActivated(void)
 {
   ToolkitTestApplication application;
@@ -861,11 +949,11 @@ int UtcDaliKeyboardFocusManagerSignalFocusedActorActivated(void)
   KeyboardFocusManager manager = KeyboardFocusManager::Get();
   DALI_TEST_CHECK(manager);
 
-  bool focusedActorActivatedSignalVerified = false;
+  bool                          focusedActorActivatedSignalVerified = false;
   FocusedActorActivatedCallback focusedActorActivatedCallback(focusedActorActivatedSignalVerified);
-  manager.FocusedActorEnterKeySignal().Connect( &focusedActorActivatedCallback, &FocusedActorActivatedCallback::Callback );
+  manager.FocusedActorEnterKeySignal().Connect(&focusedActorActivatedCallback, &FocusedActorActivatedCallback::Callback);
 
-  Integration::KeyEvent returnEvent( "Return", "", 0, 0, 0, Integration::KeyEvent::Up, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
+  Integration::KeyEvent returnEvent("Return", "", "", 0, 0, 0, Integration::KeyEvent::UP, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 
   // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
   // It makes mIsFocusIndicatorEnabled true
@@ -873,13 +961,13 @@ int UtcDaliKeyboardFocusManagerSignalFocusedActorActivated(void)
 
   // Create the first button and add it to the stage
   PushButton firstPushButton = PushButton::New();
-  firstPushButton.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(firstPushButton);
+  firstPushButton.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(firstPushButton);
 
   // Create the second button and add it to the stage
   PushButton secondPushButton = PushButton::New();
-  secondPushButton.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(secondPushButton);
+  secondPushButton.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(secondPushButton);
 
   // Check that the focus is set on the first button
   DALI_TEST_CHECK(manager.SetCurrentFocusActor(firstPushButton) == true);
@@ -911,20 +999,20 @@ int UtcDaliKeyboardFocusManagerSignalFocusGroupChanged(void)
 
   // Register Type
   TypeInfo type;
-  type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
-  DALI_TEST_CHECK( type );
+  type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+  DALI_TEST_CHECK(type);
   BaseHandle handle = type.CreateInstance();
-  DALI_TEST_CHECK( handle );
+  DALI_TEST_CHECK(handle);
 
   KeyboardFocusManager manager = KeyboardFocusManager::Get();
   DALI_TEST_CHECK(manager);
 
-  bool focusGroupChangedSignalVerified = false;
+  bool                      focusGroupChangedSignalVerified = false;
   FocusGroupChangedCallback focusGroupChangedCallback(focusGroupChangedSignalVerified);
-  manager.FocusGroupChangedSignal().Connect( &focusGroupChangedCallback, &FocusGroupChangedCallback::Callback );
+  manager.FocusGroupChangedSignal().Connect(&focusGroupChangedCallback, &FocusGroupChangedCallback::Callback);
 
-  Integration::KeyEvent tabEvent( "Tab", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
-  Integration::KeyEvent shiftTabEvent( "Tab", "", 0, 1, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
+  Integration::KeyEvent tabEvent("Tab", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+  Integration::KeyEvent shiftTabEvent("Tab", "", "", 0, 1, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 
   // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
   // It makes mIsFocusIndicatorEnabled true
@@ -951,13 +1039,13 @@ int UtcDaliKeyboardFocusManagerSignals(void)
   ToolkitTestApplication application;
 
   KeyboardFocusManager manager = KeyboardFocusManager::Get();
-  DALI_TEST_CHECK( manager );
+  DALI_TEST_CHECK(manager);
 
   ConnectionTracker* testTracker = new ConnectionTracker();
-  DALI_TEST_EQUALS( true, manager.ConnectSignal( testTracker, "keyboardPreFocusChange", CallbackFunctor() ), TEST_LOCATION );
-  DALI_TEST_EQUALS( true, manager.ConnectSignal( testTracker, "keyboardFocusChanged", CallbackFunctor() ), TEST_LOCATION );
-  DALI_TEST_EQUALS( true, manager.ConnectSignal( testTracker, "keyboardFocusGroupChanged", CallbackFunctor() ), TEST_LOCATION );
-  DALI_TEST_EQUALS( true, manager.ConnectSignal( testTracker, "keyboardFocusedActorEnterKey", CallbackFunctor() ), TEST_LOCATION );
+  DALI_TEST_EQUALS(true, manager.ConnectSignal(testTracker, "keyboardPreFocusChange", CallbackFunctor()), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, manager.ConnectSignal(testTracker, "keyboardFocusChanged", CallbackFunctor()), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, manager.ConnectSignal(testTracker, "keyboardFocusGroupChanged", CallbackFunctor()), TEST_LOCATION);
+  DALI_TEST_EQUALS(true, manager.ConnectSignal(testTracker, "keyboardFocusedActorEnterKey", CallbackFunctor()), TEST_LOCATION);
 
   END_TEST;
 }
@@ -973,23 +1061,23 @@ int UtcDaliKeyboardFocusManagerMoveFocusBackward(void)
 
   // Create the first actor and add it to the stage
   Actor first = Actor::New();
-  first.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(first);
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(first);
 
   // Create the second actor and add it to the stage
   Actor second = Actor::New();
-  second.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(second);
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(second);
 
   // Create the third actor and add it to the stage
   Actor third = Actor::New();
-  third.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(third);
+  third.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(third);
 
   // Create the fourth actor and add it to the stage
   Actor fourth = Actor::New();
-  fourth.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(fourth);
+  fourth.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(fourth);
 
   // Check that the focus is set on the second actor
   DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
@@ -1027,15 +1115,15 @@ int UtcDaliKeyboardFocusManagerMoveFocusBackward(void)
   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
 
   // Make history stack full
-  for(int i = 0 ; i < 31 ; i ++)
+  for(int i = 0; i < 31; i++)
   {
     Actor actor = Actor::New();
-    actor.SetKeyboardFocusable(true);
-    Stage::GetCurrent().Add(actor);
+    actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+    application.GetScene().Add(actor);
     manager.SetCurrentFocusActor(actor);
   }
 
-  for(int i = 0 ; i < 31 ; i ++)
+  for(int i = 0; i < 31; i++)
   {
     manager.MoveFocusBackward();
   }
@@ -1055,44 +1143,44 @@ int UtcDaliKeyboardFocusManagerChangeFocusDirectionByKeyEvents(void)
   KeyboardFocusManager manager = KeyboardFocusManager::Get();
   DALI_TEST_CHECK(manager);
 
-  bool preFocusChangeSignalVerified = false;
+  bool                   preFocusChangeSignalVerified = false;
   PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
-  manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+  manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
 
-  bool focusChangedSignalVerified = false;
+  bool                 focusChangedSignalVerified = false;
   FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
-  manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+  manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
 
-  Integration::KeyEvent leftEvent( "Left", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
-  Integration::KeyEvent rightEvent( "Right", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
-  Integration::KeyEvent upEvent( "Up", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
-  Integration::KeyEvent downEvent( "Down", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
-  Integration::KeyEvent pageUpEvent( "Prior", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
-  Integration::KeyEvent pageDownEvent( "Next", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
+  Integration::KeyEvent leftEvent("Left", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+  Integration::KeyEvent rightEvent("Right", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+  Integration::KeyEvent upEvent("Up", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+  Integration::KeyEvent downEvent("Down", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+  Integration::KeyEvent pageUpEvent("Prior", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+  Integration::KeyEvent pageDownEvent("Next", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 
   // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
   // It makes mIsFocusIndicatorEnabled true
   application.ProcessEvent(leftEvent);
 
   // Create a 2x2 table view and try to move focus inside it
-  TableView tableView = TableView::New( 2, 2 );
-  Stage::GetCurrent().Add(tableView);
+  TableView tableView = TableView::New(2, 2);
+  application.GetScene().Add(tableView);
 
   // Create the first actor
   Actor first = Actor::New();
-  first.SetKeyboardFocusable(true);
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 
   // Create the second actor
   Actor second = Actor::New();
-  second.SetKeyboardFocusable(true);
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 
   // Create the third actor
   Actor third = Actor::New();
-  third.SetKeyboardFocusable(true);
+  third.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 
   // Create the fourth actor
   Actor fourth = Actor::New();
-  fourth.SetKeyboardFocusable(true);
+  fourth.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 
   // Add the four children to table view
   tableView.AddChild(first, TableView::CellPosition(0, 0));
@@ -1182,12 +1270,68 @@ int UtcDaliKeyboardFocusManagerChangeFocusDirectionByKeyEvents(void)
   DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
   DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::RIGHT);
 
+  // Clear the focus again
+  manager.ClearFocus();
+
+  // Send the up event for line coverage, but nothing was focued so focus manager will try the initial focus
+  preFocusChangeCallback.Reset();
+  application.ProcessEvent(upEvent);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+  DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+  DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
+  DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
+
+  // Clear the focus again
+  manager.ClearFocus();
+
+  // Send the down event for line coverage, but nothing was focued so focus manager will try the initial focus
+  preFocusChangeCallback.Reset();
+  application.ProcessEvent(downEvent);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+  DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+  DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
+  DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
+
   END_TEST;
 }
 
+int UtcDaliKeyboardFocusManagerSignalChangedBySpaceKeyEvent(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline(" UtcDaliKeyboardFocusManagerSignalChangedBySpaceKeyEvent");
+
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(manager);
+
+  bool                   preFocusChangeSignalVerified = false;
+  PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
+  manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
 
+  Integration::KeyEvent spaceEvent("space", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+
+  // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
+  // It makes mIsFocusIndicatorEnabled true
+  application.ProcessEvent(spaceEvent);
+
+  // Send the space event
+  application.ProcessEvent(spaceEvent);
+  DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+  DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
+
+  // Clear the focus again
+  manager.ClearFocus();
 
+  // Send the space event again for line coverage
+  preFocusChangeCallback.Reset();
+  application.ProcessEvent(spaceEvent);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+  DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
+  DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == Actor());
+  DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
 
+  END_TEST;
+}
 
 int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
 {
@@ -1197,31 +1341,31 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
 
   // Register Type
   TypeInfo type;
-  type = TypeRegistry::Get().GetTypeInfo( "KeyboardFocusManager" );
-  DALI_TEST_CHECK( type );
+  type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+  DALI_TEST_CHECK(type);
   BaseHandle handle = type.CreateInstance();
-  DALI_TEST_CHECK( handle );
+  DALI_TEST_CHECK(handle);
 
   KeyboardFocusManager manager = KeyboardFocusManager::Get();
   DALI_TEST_CHECK(manager);
 
-  bool preFocusChangeSignalVerified = false;
+  bool                   preFocusChangeSignalVerified = false;
   PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified);
-  manager.PreFocusChangeSignal().Connect( &preFocusChangeCallback, &PreFocusChangeCallback::Callback );
+  manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
 
-  bool focusChangedSignalVerified = false;
+  bool                 focusChangedSignalVerified = false;
   FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
-  manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+  manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
 
   // Create the first actor and add it to the stage
   Control first = Control::New();
-  first.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(first);
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(first);
 
   // Create the second actor and add it to the stage
   Control second = Control::New();
-  second.SetKeyboardFocusable(true);
-  Stage::GetCurrent().Add(second);
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(second);
 
   // Move the focus to the right
   DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == false);
@@ -1239,7 +1383,7 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
-  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
   focusChangedCallback.Reset();
 
   // Move the focus towards right
@@ -1258,8 +1402,8 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == second);
-  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
   focusChangedCallback.Reset();
 
   // Move the focus towards up
@@ -1274,16 +1418,16 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
   DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
 
   // Create a 2x2 table view and try to move focus inside it
-  TableView tableView = TableView::New( 2, 2 );
-  Stage::GetCurrent().Add(tableView);
+  TableView tableView = TableView::New(2, 2);
+  application.GetScene().Add(tableView);
 
   // Create the third actor
   Control third = Control::New();
-  third.SetKeyboardFocusable(true);
+  third.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 
   // Create the fourth actor
   Control fourth = Control::New();
-  fourth.SetKeyboardFocusable(true);
+  fourth.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 
   // Add the four children to table view
   tableView.AddChild(first, TableView::CellPosition(0, 0));
@@ -1298,8 +1442,8 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
 
-  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
-  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
+  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
 
   focusChangedCallback.Reset();
 
@@ -1309,8 +1453,8 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == second);
-  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
 
   focusChangedCallback.Reset();
 
@@ -1321,10 +1465,10 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == fourth);
 
-  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
 
   focusChangedCallback.Reset();
 
@@ -1335,10 +1479,10 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == fourth);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == third);
 
-  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
-  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
+  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
 
   focusChangedCallback.Reset();
 
@@ -1348,10 +1492,10 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
   DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == third);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
-  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
-  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
+  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
   focusChangedCallback.Reset();
 
   // Move the focus towards left. The focus move will fail as no way to move it upwards
@@ -1361,10 +1505,10 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
   DALI_TEST_CHECK(preFocusChangeCallback.mCurrentFocusedActor == first);
   DALI_TEST_CHECK(preFocusChangeCallback.mProposedActorToFocus == Actor());
   DALI_TEST_CHECK(preFocusChangeCallback.mDirection == Control::KeyboardFocus::LEFT);
-  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
-  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
+  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
 
   preFocusChangeCallback.Reset();
   DALI_TEST_CHECK(!focusChangedCallback.mSignalVerified);
@@ -1380,20 +1524,19 @@ int UtcDaliKeyboardFocusManagerMoveFocusTestStateChange(void)
   DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
   DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == fourth);
 
-  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION );
+  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
 
   focusChangedCallback.Reset();
 
   // Clear the focus
   manager.ClearFocus();
-  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION );
-
+  DALI_TEST_EQUALS(first.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(second.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(third.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
+  DALI_TEST_EQUALS(fourth.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::NORMAL, TEST_LOCATION);
 
   END_TEST;
 }
@@ -1402,26 +1545,26 @@ int UtcDaliKeyboardFocusManagerFocusedActorUnstaged(void)
 {
   ToolkitTestApplication application;
 
-  tet_infoline( "Ensure we cannot set an actor to be focused if it is not staged and that we do not retrieve an actor if it has been unstaged" );
+  tet_infoline("Ensure we cannot set an actor to be focused if it is not staged and that we do not retrieve an actor if it has been unstaged");
 
   KeyboardFocusManager manager = KeyboardFocusManager::Get();
-  DALI_TEST_CHECK( ! manager.GetCurrentFocusActor() );
+  DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
 
   Actor actor = Actor::New();
-  actor.SetKeyboardFocusable( true );
+  actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 
-  tet_infoline( "Attempt to set unstaged actor, no actor should be returned from KeyboardFocusManager" );
-  manager.SetCurrentFocusActor( actor );
-  DALI_TEST_CHECK( ! manager.GetCurrentFocusActor() );
+  tet_infoline("Attempt to set unstaged actor, no actor should be returned from KeyboardFocusManager");
+  manager.SetCurrentFocusActor(actor);
+  DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
 
-  tet_infoline( "Add actor to stage and attempt to set, our actor should be returned from KeyboardFocusManager" );
-  Stage::GetCurrent().Add( actor );
-  manager.SetCurrentFocusActor( actor );
-  DALI_TEST_CHECK( manager.GetCurrentFocusActor() == actor );
+  tet_infoline("Add actor to stage and attempt to set, our actor should be returned from KeyboardFocusManager");
+  application.GetScene().Add(actor);
+  manager.SetCurrentFocusActor(actor);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == actor);
 
-  tet_infoline( "Remove actor from stage and attempt to retrieve, no actor should be returned from KeyboardFocusManager" );
+  tet_infoline("Remove actor from stage and attempt to retrieve, no actor should be returned from KeyboardFocusManager");
   actor.Unparent();
-  DALI_TEST_CHECK( ! manager.GetCurrentFocusActor() );
+  DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
 
   END_TEST;
 }
@@ -1430,34 +1573,819 @@ int UtcDaliKeyboardFocusManagerEnableFocusIndicator(void)
 {
   ToolkitTestApplication application;
 
-  tet_infoline( "Ensure we cannot set an actor to be focused if it is not staged and that we do not retrieve an actor if it has been unstaged" );
+  tet_infoline("Ensure we cannot set an actor to be focused if it is not staged and that we do not retrieve an actor if it has been unstaged");
 
   KeyboardFocusManager manager = KeyboardFocusManager::Get();
-  DALI_TEST_CHECK( ! manager.GetCurrentFocusActor() );
+  DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
 
   Actor actor = Actor::New();
-  actor.SetKeyboardFocusable( true );
-  Stage::GetCurrent().Add( actor );
-  manager.SetCurrentFocusActor( actor );
+  actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(actor);
+  manager.SetCurrentFocusActor(actor);
 
   // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
   // It makes mIsFocusIndicatorEnabled true and add focus indicator to focused actor.
-  Integration::KeyEvent rightEvent( "Right", "", 0, 0, 0, Integration::KeyEvent::Down, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
+  Integration::KeyEvent rightEvent("Right", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
   application.ProcessEvent(rightEvent);
 
   Actor indicatorActor = manager.GetFocusIndicatorActor();
 
-  tet_infoline( "Indicator is added to focused actor" );
-  DALI_TEST_CHECK( actor == indicatorActor.GetParent() );
+  tet_infoline("Indicator is added to focused actor");
+  DALI_TEST_CHECK(actor == indicatorActor.GetParent());
 
   Dali::Toolkit::DevelKeyboardFocusManager::EnableFocusIndicator(manager, false);
-  DALI_TEST_CHECK( !Dali::Toolkit::DevelKeyboardFocusManager::IsFocusIndicatorEnabled(manager) );
+  DALI_TEST_CHECK(!Dali::Toolkit::DevelKeyboardFocusManager::IsFocusIndicatorEnabled(manager));
+
+  tet_infoline("Indicator is removed from focused actor because mUseFocusIndicator is false");
+  DALI_TEST_CHECK(!indicatorActor.GetParent());
+
+  END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerCheckConsumedKeyEvent(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline("Ensure Window can't receive KeyEvent when Control already consumed it");
+  Dali::Integration::Scene scene = application.GetScene();
+
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
+
+  // Create the first actor and add it to the stage
+  Control control = Control::New();
+  control.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  scene.Add(control);
+
+  KeyEventCallback controlCallback(true);
+  control.KeyEventSignal().Connect(&controlCallback, &KeyEventCallback::Callback);
+
+  KeyEventCallback sceneCallback(false);
+  scene.KeyEventSignal().Connect(&sceneCallback, &KeyEventCallback::Callback);
+
+  manager.SetCurrentFocusActor(control);
+
+  // Press Any key to notice physical keyboard event is comming to KeyboardFocusManager
+  // It makes mIsFocusIndicatorEnabled true and add focus indicator to focused actor.
+  Integration::KeyEvent event1("Right", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+  application.ProcessEvent(event1);
+
+  DALI_TEST_CHECK(controlCallback.mIsCalled);
+  DALI_TEST_CHECK(!sceneCallback.mIsCalled);
+
+  END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerFocusPerWindow(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline("Ensure Memory focus actors for each window ");
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
+
+  Window firstWindow = Window::New(PositionSize(0, 0, 300, 500), "", false);
+  DALI_TEST_CHECK(firstWindow);
+  Control first = Control::New();
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  firstWindow.Add(first);
+
+  Window secondWindow = Window::New(PositionSize(0, 0, 400, 600), "", false);
+  DALI_TEST_CHECK(secondWindow);
+  Control second = Control::New();
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  secondWindow.Add(second);
+
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+  firstWindow.Raise();
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+  secondWindow.Remove(second);
+  secondWindow.Raise();
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() != second);
+
+  secondWindow.Reset();
+  END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline(" UtcDaliKeyboardFocusManagerWithoutFocusablePropertiesMoveFocus");
+
+  // Register Type
+  TypeInfo type;
+  type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+  DALI_TEST_CHECK(type);
+  BaseHandle handle = type.CreateInstance();
+  DALI_TEST_CHECK(handle);
+
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(manager);
+
+  bool                 focusChangedSignalVerified = false;
+  FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
+  manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
+
+  PushButton button1 = PushButton::New();
+  PushButton button2 = PushButton::New();
+  PushButton button3 = PushButton::New();
+  PushButton button4 = PushButton::New();
+  PushButton button5 = PushButton::New();
+
+  button1.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+  button2.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+  button3.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+  button4.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+  button5.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+
+  button1.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  button2.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  button3.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  button4.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  button5.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+  application.GetScene().Add(button1);
+  application.GetScene().Add(button2);
+  application.GetScene().Add(button3);
+  button5.Add(button4);
+  application.GetScene().Add(button5);
+
+  // set position
+  // button1 -- button2
+  //   |           |
+  //   |    button5|
+  // button3 -- button4
+  button1.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
+  button2.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 0.0f));
+  button3.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 100.0f));
+  button4.SetProperty(Actor::Property::POSITION, Vector2(40.0f, 40.0f));
+  button5.SetProperty(Actor::Property::POSITION, Vector2(60.0f, 60.0f));
+
+  // flush the queue and render once
+  application.SendNotification();
+  application.Render();
+
+  // Set the focus to the button1
+  // [button1] -- button2
+  //   |           |
+  //   |    button5|
+  // button3 -- button4
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(button1) == true);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == button1);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+  focusChangedCallback.Reset();
+
+  // without set the navigation properties, but we can focus move
+  // enable the default algorithm
+  Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(manager, true);
+  DALI_TEST_CHECK(Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(manager));
+
+  // Move the focus towards right
+  // button1 -- [button2]
+  //   |           |
+  //   |    button5|
+  // button3 -- button4
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+  // Confirm whether focus is moved to button2
+  DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
+  focusChangedCallback.Reset();
+
+  // Move the focus towards down
+  // button1 -- button2
+  //   |           |
+  //   |  [button5]|
+  // button3 -- button4
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::DOWN) == true);
+
+  // Confirm whether focus is moved to button5
+  DALI_TEST_EQUALS(button5.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button5);
+  focusChangedCallback.Reset();
+
+  // Move the focus towards right
+  // button1 -- button2
+  //   |           |
+  //   |    button5|
+  // button3 -- [button4]
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+  // Confirm whether focus is moved to button4
+  DALI_TEST_EQUALS(button4.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button5);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button4);
+  focusChangedCallback.Reset();
+
+  // Move the focus towards left
+  // button1 -- button2
+  //   |           |
+  //   |  [button5]|
+  // button3 -- button4
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
+
+  // Confirm whether focus is moved to button5
+  DALI_TEST_EQUALS(button5.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button4);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button5);
+  focusChangedCallback.Reset();
+
+  // Move the focus towards left
+  // button1 -- button2
+  //   |           |
+  //   |    button5|
+  //[button3] -- button4
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
+
+  // Confirm whether focus is moved to button3
+  DALI_TEST_EQUALS(button3.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button5);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button3);
+  focusChangedCallback.Reset();
+
+  // Move the focus towards right
+  // button1 -- button2
+  //   |           |
+  //   |  [button5]|
+  // button3 -- button4
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+  // Confirm whether focus is moved to button5
+  DALI_TEST_EQUALS(button5.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button3);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button5);
+  focusChangedCallback.Reset();
+
+  // Move the focus towards left
+  // button1 -- button2
+  //   |           |
+  //   |    button5|
+  //[button3] -- button4
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
+
+  // Confirm whether focus is moved to button3
+  DALI_TEST_EQUALS(button3.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button5);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button3);
+  focusChangedCallback.Reset();
+
+  // Move the focus towards up
+  //[button1]-- button2
+  //   |           |
+  //   |    button5|
+  // button3 -- button4
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::UP) == true);
+
+  // Confirm whether focus is moved to button1
+  DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button3);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+  focusChangedCallback.Reset();
+
+  // Move the focus towards left. The focus move will fail as no way to move it upwards
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == false);
 
-  tet_infoline( "Indicator is removed from focused actor because mUseFocusIndicator is false" );
-  DALI_TEST_CHECK( !indicatorActor.GetParent() );
+  // Move the focus toward page up/down. The focus move will fail as invalid direction.
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::PAGE_UP) == false);
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::PAGE_DOWN) == false);
+  focusChangedCallback.Reset();
 
   END_TEST;
 }
 
+int UtcDaliKeyboardFocusManagerSetAndGetCurrentFocusActorInTouchMode(void)
+{
+  ToolkitTestApplication application;
 
+  tet_infoline(" UtcDaliKeyboardFocusManagerSetAndGetCurrentFocusActorInTouchMode");
 
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(manager);
+
+  // Create the first actor and add it to the stage
+  Actor first = Actor::New();
+  first.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+  first.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
+  first.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  first.SetProperty(DevelActor::Property::TOUCH_FOCUSABLE, true);
+  application.GetScene().Add(first);
+
+  // Create the second actor and add it to the stage
+  Actor second = Actor::New();
+  second.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+  second.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 0.0f));
+  second.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(second);
+
+  // flush the queue and render once
+  application.SendNotification();
+  application.Render();
+
+  // Check that no actor is being focused yet.
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+  // Check that it will fail to set focus on an invalid actor
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(Actor()) == false);
+
+  Dali::Integration::TouchEvent event1 = Dali::Integration::TouchEvent();
+  Dali::Integration::Point      pointDown1;
+  pointDown1.SetState(PointState::DOWN);
+  pointDown1.SetDeviceId(1);
+  // touch first actor
+  pointDown1.SetScreenPosition(Vector2(10.0f, 10.0f));
+  event1.AddPoint(pointDown1);
+  application.ProcessEvent(event1);
+
+  // flush the queue and render once
+  application.SendNotification();
+  application.Render();
+
+  // Check that the focus is successfully to the first actor
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+  Dali::Integration::TouchEvent event2 = Dali::Integration::TouchEvent();
+  Dali::Integration::Point      pointDown2;
+  pointDown2.SetState(PointState::DOWN);
+  pointDown2.SetDeviceId(1);
+  // touch second actor
+  pointDown2.SetScreenPosition(Vector2(110.0f, 10.0f));
+  event2.AddPoint(pointDown2);
+  application.ProcessEvent(event2);
+
+  // flush the queue and render once
+  application.SendNotification();
+  application.Render();
+
+  // Since no focus has been moved, the current focus actor is the same.
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+  // Make the second actor focusableInTouchMode
+  second.SetProperty(DevelActor::Property::TOUCH_FOCUSABLE, true);
+
+  // touch second actor
+  application.ProcessEvent(event2);
+
+  // flush the queue and render once
+  application.SendNotification();
+  application.Render();
+
+  // Check that the focus is successfully to the second actor
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+
+  END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerEnableDefaultAlgorithm(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline(" UtcDaliKeyboardFocusManagerEnableDefaultAlgorithm");
+
+  // Register Type
+  TypeInfo type;
+  type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+  DALI_TEST_CHECK(type);
+  BaseHandle handle = type.CreateInstance();
+  DALI_TEST_CHECK(handle);
+
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(manager);
+
+  bool                 focusChangedSignalVerified = false;
+  FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
+  manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
+
+  PushButton button1 = PushButton::New();
+  PushButton button2 = PushButton::New();
+
+  button1.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+  button2.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+
+  button1.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  button2.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+  application.GetScene().Add(button1);
+  application.GetScene().Add(button2);
+
+  // set position
+  // button1 -- button2
+  button1.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
+  button2.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 0.0f));
+  button1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  button2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+
+  // flush the queue and render once
+  application.SendNotification();
+  application.Render();
+
+  // Set the focus to the button1
+  // [button1] -- button2
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(button1) == true);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == button1);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+  focusChangedCallback.Reset();
+
+  // without set the navigation properties, but we can focus move
+  // enable the default algorithm
+  Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(manager, true);
+  DALI_TEST_CHECK(Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(manager));
+
+  // Move the focus towards right
+  // button1 -- [button2]
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+  // Confirm whether focus is moved to button2
+  DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
+  focusChangedCallback.Reset();
+
+  // disable the default algorithm
+  Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(manager, false);
+  DALI_TEST_CHECK(!Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(manager));
+
+  // Move the focus towards left, The focus move will fail because the default algorithm is disabled.
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == false);
+
+  // enable the default algorithm
+  Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(manager, true);
+  DALI_TEST_CHECK(Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(manager));
+
+  // Move the focus towards left, The focus move will success because the default algorithm is enabled.
+  // [button1] -- button2
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::LEFT) == true);
+  // Confirm whether focus is moved to button1
+  DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button2);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+  focusChangedCallback.Reset();
+
+  // Clears focus.
+  manager.ClearFocus();
+  // There is no actor focused.
+  // button1 -- button2
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+  // Move the focus towards right, The focus is on the actor closest to the top left of the window.
+  // [button1] -- button2
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+  // Confirm whether focus is moved to button1
+  DALI_TEST_EQUALS(button1.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+  focusChangedCallback.Reset();
+
+
+  END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerWithKeyboardFocusableChildren(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline(" UtcDaliKeyboardFocusManagerWithKeyboardFocusableChildren");
+
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(manager);
+
+  // Create the first actor and add it to the stage
+  Actor first = Actor::New();
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(first);
+
+  // Create the second actor and add it to the first actor.
+  Actor second = Actor::New();
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  first.Add(second);
+
+  // Check that no actor is being focused yet.
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+  // Check that the focus is set on the first actor
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+  // Set KeyboardFocusableChildren false.
+  first.SetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, false);
+
+  // Check that it will fail to set focus on the second actor as it's not focusable
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == false);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+  // Set KeyboardFocusableChildren true.
+  first.SetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, true);
+
+  // Check that the focus is set on the second actor
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+
+  END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerCheckWheelEvent(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline("UtcDaliKeyboardFocusManagerCheckWheelEvent");
+  Dali::Integration::Scene scene = application.GetScene();
+
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(!manager.GetCurrentFocusActor());
+
+  // Create the first actor and add it to the stage
+  Actor parent = Actor::New();
+  parent.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+  Actor child = Actor::New();
+  child.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+  parent.Add(child);
+  scene.Add(parent);
+
+  WheelEventCallback childCallback(false);
+  child.WheelEventSignal().Connect(&childCallback, &WheelEventCallback::Callback);
+
+  WheelEventCallback parentCallback(true);
+  parent.WheelEventSignal().Connect(&parentCallback, &WheelEventCallback::Callback);
+
+  WheelEventCallback sceneCallback(false);
+  scene.WheelEventSignal().Connect(&sceneCallback, &WheelEventCallback::Callback);
+
+  manager.SetCurrentFocusActor(child);
+
+  // Emit custom wheel event is comming to KeyboardFocusManager
+  Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
+  application.ProcessEvent(event);
+
+  DALI_TEST_CHECK(childCallback.mIsCalled);
+  DALI_TEST_CHECK(parentCallback.mIsCalled);
+  DALI_TEST_CHECK(!sceneCallback.mIsCalled);
+
+  END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerChangeFocusDirectionByCustomWheelEvent(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline(" UtcDaliKeyboardFocusManagerChangeFocusDirectionByCustomWheelEvent");
+  Dali::Integration::Scene scene = application.GetScene();
+
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(manager);
+
+  bool focusChangedSignalVerified = false;
+  FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
+  manager.FocusChangedSignal().Connect( &focusChangedCallback, &FocusChangedCallback::Callback );
+
+  Integration::WheelEvent clockwiseEvent(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
+  Integration::WheelEvent counterClockwiseEvent(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1100u);
+
+  // Create the first button
+  PushButton first = PushButton::New();
+  first.SetProperty( Actor::Property::KEYBOARD_FOCUSABLE,true);
+  scene.Add(first);
+
+  // Create the second button
+  PushButton second = PushButton::New();
+  second.SetProperty( Actor::Property::KEYBOARD_FOCUSABLE,true);
+  scene.Add(second);
+
+   // set the navigation properties
+  first.SetProperty(Toolkit::DevelControl::Property::CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)second.GetProperty< int >( Actor::Property::ID )));
+  second.SetProperty(Toolkit::DevelControl::Property::COUNTER_CLOCKWISE_FOCUSABLE_ACTOR_ID, Property::Value((int)first.GetProperty< int >( Actor::Property::ID )));
+
+  // Set the focus to the first actor
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
+  focusChangedCallback.Reset();
+
+  // Send the clockwise wheel event to move the focus towards clockwise
+  application.ProcessEvent(clockwiseEvent);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == first);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == second);
+  focusChangedCallback.Reset();
+
+  // Send the counter clockwise wheel event to move the focus towards count clockwise
+  application.ProcessEvent(counterClockwiseEvent);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == second);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == first);
+  focusChangedCallback.Reset();
+
+  // Clear the focus
+  manager.ClearFocus();
+
+  END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerWithUserInteractionEnabled(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline(" UtcDaliKeyboardFocusManagerWithUserInteractionEnabled");
+
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(manager);
+
+  // Create the first control and add it to the stage
+  Control first = Control::New();
+  first.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(first);
+
+  // Create the second control and add it to the first control.
+  Control second = Control::New();
+  second.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  first.Add(second);
+
+  // Check that no actor is being focused yet.
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+  // Check that the focus is set on the first actor
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+  // Set USER_INTERACTION_ENABLED false.
+  second.SetProperty(DevelActor::Property::USER_INTERACTION_ENABLED, false);
+
+  // Check that it will fail to set focus on the second actor as it's not userInteractionEnabled
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == false);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
+
+  // Set KeyboardFocusableChildren true.
+  second.SetProperty(DevelActor::Property::USER_INTERACTION_ENABLED, true);
+
+  // Check that the focus is set on the second actor
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
+
+  // If the currently focused actor becomes USER_INTERACTION_ENABLED false, it loses focus.
+  second.SetProperty(DevelActor::Property::USER_INTERACTION_ENABLED, false);
+
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+
+  END_TEST;
+}
+
+int UtcDaliKeyboardFocusManagerFocusFinderRootActor(void)
+{
+  ToolkitTestApplication application;
+
+  tet_infoline(" UtcDaliKeyboardFocusManagerFocusFinderRootActor");
+
+  // Register Type
+  TypeInfo type;
+  type = TypeRegistry::Get().GetTypeInfo("KeyboardFocusManager");
+  DALI_TEST_CHECK(type);
+  BaseHandle handle = type.CreateInstance();
+  DALI_TEST_CHECK(handle);
+
+  KeyboardFocusManager manager = KeyboardFocusManager::Get();
+  DALI_TEST_CHECK(manager);
+
+  bool                 focusChangedSignalVerified = false;
+  FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
+  manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
+
+  PushButton button1 = PushButton::New();
+  PushButton button2 = PushButton::New();
+
+  button1.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+  button2.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+
+  button1.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  button2.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+  application.GetScene().Add(button1);
+  application.GetScene().Add(button2);
+
+  Actor actor = Actor::New();
+  actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  application.GetScene().Add(actor);
+
+  PushButton buttonA = PushButton::New();
+  PushButton buttonB = PushButton::New();
+
+  buttonA.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+  buttonB.SetProperty(Actor::Property::SIZE, Vector2(50, 50));
+
+  buttonA.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+  buttonB.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+
+  actor.Add(buttonA);
+  actor.Add(buttonB);
+
+  // set position
+  // button1 -- button2
+  button1.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
+  button2.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 0.0f));
+  button1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  button2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+
+  // buttonA -- buttonB
+  buttonA.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 50.0f));
+  buttonB.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 50.0f));
+  buttonA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+  buttonB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+
+  // flush the queue and render once
+  application.SendNotification();
+  application.Render();
+
+  // Set the focus to the button1
+  // [button1] -- button2
+  DALI_TEST_CHECK(manager.SetCurrentFocusActor(button1) == true);
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == button1);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button1);
+  focusChangedCallback.Reset();
+
+  // without set the navigation properties, but we can focus move
+  // enable the default algorithm
+  Dali::Toolkit::DevelKeyboardFocusManager::EnableDefaultAlgorithm(manager, true);
+  DALI_TEST_CHECK(Dali::Toolkit::DevelKeyboardFocusManager::IsDefaultAlgorithmEnabled(manager));
+
+  // Move the focus towards right
+  // button1 -- [button2]
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+  // Confirm whether focus is moved to button2
+  DALI_TEST_EQUALS(button2.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == button1);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == button2);
+  focusChangedCallback.Reset();
+
+  // Clears focus.
+  manager.ClearFocus();
+
+  // There is no actor focused.
+  // button1 -- button2
+  // buttonA -- buttonB
+  DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
+
+  // Sets the actor to root.
+  Dali::Toolkit::DevelKeyboardFocusManager::SetFocusFinderRootActor(manager, actor);
+
+  // Move the focus towards right
+  // [buttonA] -- buttonB
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+
+  // Confirm whether focus is moved to buttonA
+  // Because the root is an actor, the focus is moved to buttonA, a child of the actor.
+  DALI_TEST_EQUALS(buttonA.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == Actor());
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == buttonA);
+  focusChangedCallback.Reset();
+
+
+  // Move the focus towards right, The focus move will success.
+  // buttonA -- [buttonB]
+  DALI_TEST_CHECK(manager.MoveFocus(Control::KeyboardFocus::RIGHT) == true);
+  // Confirm whether focus is moved to buttonB
+  DALI_TEST_EQUALS(buttonB.GetProperty<int>(DevelControl::Property::STATE), (int)DevelControl::FOCUSED, TEST_LOCATION);
+  DALI_TEST_CHECK(focusChangedCallback.mSignalVerified);
+  DALI_TEST_CHECK(focusChangedCallback.mOriginalFocusedActor == buttonA);
+  DALI_TEST_CHECK(focusChangedCallback.mCurrentFocusedActor == buttonB);
+  focusChangedCallback.Reset();
+
+  // reset
+  Dali::Toolkit::DevelKeyboardFocusManager::ResetFocusFinderRootActor(manager);
+
+  END_TEST;
+}