Accessibility Manager public API UTC tests and coverage

Change-Id: I861347f17d5c27f284c56fc509734ed33f6c2dd9

diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp
index 9ba46ca..a69b323 100644 (file)
--- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp
+++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.cpp
@@ -18,6 +18,8 @@
 #include "toolkit-accessibility-adaptor.h"
 
 #include <dali/public-api/object/base-object.h>
+#include <dali/public-api/object/base-object.h>
+#include <dali/devel-api/adaptor-framework/accessibility-action-handler.h>
 
 namespace Dali
 {
@@ -42,10 +44,46 @@ public: // Creation & Destruction
 
 public:
 
+  // Functions to modify mock returns:
+
+  void MockSetReadPosition( Vector2& position );
+
+public:
+
   bool IsEnabled() const;
   void SetActionHandler(Dali::AccessibilityActionHandler& handler);
   void SetGestureHandler(Dali::AccessibilityGestureHandler& handler);
 
+  Vector2 GetReadPosition() const;
+
+  bool HandleActionNextEvent();
+  bool HandleActionPreviousEvent();
+  bool HandleActionActivateEvent();
+  bool HandleActionReadEvent(unsigned int x, unsigned int y, bool allowReadAgain);
+  bool HandleActionReadNextEvent();
+  bool HandleActionReadPreviousEvent();
+  bool HandleActionUpEvent();
+  bool HandleActionDownEvent();
+  bool HandleActionClearFocusEvent();
+  bool HandleActionScrollEvent(TouchPoint& point, unsigned long timeStamp);
+  bool HandleActionBackEvent();
+  bool HandleActionEnableEvent();
+  bool HandleActionDisableEvent();
+  bool HandleActionScrollUpEvent();
+  bool HandleActionScrollDownEvent();
+  bool HandleActionPageLeftEvent();
+  bool HandleActionPageRightEvent();
+  bool HandleActionPageUpEvent();
+  bool HandleActionPageDownEvent();
+  bool HandleActionMoveToFirstEvent();
+  bool HandleActionMoveToLastEvent();
+  bool HandleActionReadFromTopEvent();
+  bool HandleActionReadFromNextEvent();
+  bool HandleActionZoomEvent();
+  bool HandleActionReadIndicatorInformationEvent();
+  bool HandleActionReadPauseResumeEvent();
+  bool HandleActionStartStopEvent();
+
 public: // Signals
 
 private:
@@ -53,6 +91,7 @@ private:
   bool mIsEnabled;
   Dali::AccessibilityActionHandler* mActionHandler;
   Dali::AccessibilityGestureHandler* mGestureHandler;
+  Vector2 mReadPosition;
 
   static Dali::AccessibilityAdaptor mToolkitAccessibilityAdaptor;
 };
@@ -62,7 +101,7 @@ Dali::AccessibilityAdaptor AccessibilityAdaptor::mToolkitAccessibilityAdaptor;
 
 Dali::AccessibilityAdaptor AccessibilityAdaptor::Get()
 {
-  if( ! mToolkitAccessibilityAdaptor )
+  if( !mToolkitAccessibilityAdaptor )
   {
     mToolkitAccessibilityAdaptor = Dali::AccessibilityAdaptor( new Dali::Internal::Adaptor::AccessibilityAdaptor() );
   }
@@ -70,7 +109,8 @@ Dali::AccessibilityAdaptor AccessibilityAdaptor::Get()
 }
 
 AccessibilityAdaptor::AccessibilityAdaptor()
-: mIsEnabled(false)
+: mIsEnabled(false),
+  mReadPosition( 0.0f, 0.0f )
 {
 }
 
@@ -78,6 +118,16 @@ AccessibilityAdaptor::~AccessibilityAdaptor()
 {
 }
 
+Vector2 AccessibilityAdaptor::GetReadPosition() const
+{
+  return mReadPosition;
+}
+
+void AccessibilityAdaptor::MockSetReadPosition( Vector2& position )
+{
+  mReadPosition = position;
+}
+
 bool AccessibilityAdaptor::IsEnabled() const
 {
   return mIsEnabled;
@@ -93,6 +143,251 @@ void AccessibilityAdaptor::SetGestureHandler(Dali::AccessibilityGestureHandler&
   mGestureHandler = &handler;
 }
 
+bool AccessibilityAdaptor::HandleActionNextEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionNext( true );
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionPreviousEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionPrevious( true );
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionActivateEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionActivate();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionReadEvent(unsigned int x, unsigned int y,  bool allowReadAgain)
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionRead( allowReadAgain );
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionReadNextEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionReadNext( true );
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionReadPreviousEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionReadPrevious( true );
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionUpEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionUp();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionDownEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionDown();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionClearFocusEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->ClearAccessibilityFocus();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionScrollEvent(TouchPoint& point, unsigned long timeStamp)
+{
+  if( mActionHandler )
+  {
+    Dali::TouchEvent touchEvent;
+    touchEvent.points.push_back( point );
+    return mActionHandler->AccessibilityActionScroll( touchEvent );
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionBackEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionBack();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionEnableEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->ChangeAccessibilityStatus();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionDisableEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->ChangeAccessibilityStatus();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionScrollUpEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionScrollUp();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionScrollDownEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionScrollDown();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionPageLeftEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionPageLeft();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionPageRightEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionPageRight();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionPageUpEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionPageUp();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionPageDownEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionPageDown();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionMoveToFirstEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionMoveToFirst();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionMoveToLastEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionMoveToLast();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionReadFromTopEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionReadFromTop();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionReadFromNextEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionReadFromNext();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionZoomEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionZoom();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionReadIndicatorInformationEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionReadIndicatorInformation();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionReadPauseResumeEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionReadPauseResume();
+  }
+  return false;
+}
+
+bool AccessibilityAdaptor::HandleActionStartStopEvent()
+{
+  if( mActionHandler )
+  {
+    return mActionHandler->AccessibilityActionStartStop();
+  }
+  return false;
+}
+
 static Internal::Adaptor::AccessibilityAdaptor& GetImplementation(Dali::AccessibilityAdaptor& adaptor)
 {
   BaseObject& handle = adaptor.GetBaseObject();
@@ -118,10 +413,18 @@ AccessibilityAdaptor::~AccessibilityAdaptor()
 {
 }
 
-Vector2 AccessibilityAdaptor::GetReadPosition() const
+// Mock setup:
+
+void AccessibilityAdaptor::MockSetReadPosition( Vector2& position )
+{
+  Internal::Adaptor::GetImplementation(*this).MockSetReadPosition( position );
+}
+
+// Methods:
+
+Vector2 AccessibilityAdaptor::GetReadPosition()
 {
-  //return Internal::Adaptor::GetImplementation(*this).GetReadPosition();
-  return Vector2::ZERO;
+  return Internal::Adaptor::GetImplementation(*this).GetReadPosition();
 }
 
 bool AccessibilityAdaptor::IsEnabled() const
@@ -142,137 +445,137 @@ void AccessibilityAdaptor::SetGestureHandler(AccessibilityGestureHandler& handle
 
 bool AccessibilityAdaptor::HandleActionNextEvent()
 {
-  return true; //Internal::Adaptor::GetImplementation(*this).HandleActionNextEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionNextEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionPreviousEvent()
 {
-  return true; //Internal::Adaptor::GetImplementation(*this).HandleActionPreviousEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionPreviousEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionActivateEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionActivateEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionActivateEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionReadEvent(unsigned int x, unsigned int y,  bool allowReadAgain)
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionReadEvent(x, y, allowReadAgain);
+  return Internal::Adaptor::GetImplementation(*this).HandleActionReadEvent( x, y, allowReadAgain );
 }
 
 bool AccessibilityAdaptor::HandleActionReadNextEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionReadNextEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionReadNextEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionReadPreviousEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionReadPreviousEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionReadPreviousEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionUpEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionUpEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionUpEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionDownEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionDownEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionDownEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionClearFocusEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionClearFocusEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionClearFocusEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionScrollEvent(TouchPoint& point, unsigned long timeStamp)
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionScrollEvent(point, timeStamp);
+  return Internal::Adaptor::GetImplementation(*this).HandleActionScrollEvent(point, timeStamp);
 }
 
 bool AccessibilityAdaptor::HandleActionBackEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionBackEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionBackEvent();
 }
 
 void AccessibilityAdaptor::HandleActionEnableEvent()
 {
-  //Internal::Adaptor::GetImplementation(*this).HandleActionEnableEvent();
+  Internal::Adaptor::GetImplementation(*this).HandleActionEnableEvent();
 }
 
 void AccessibilityAdaptor::HandleActionDisableEvent()
 {
-  //Internal::Adaptor::GetImplementation(*this).HandleActionDisableEvent();
+  Internal::Adaptor::GetImplementation(*this).HandleActionDisableEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionScrollUpEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionScrollUpEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionScrollUpEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionScrollDownEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionScrollDownEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionScrollDownEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionPageLeftEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionPageLeftEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionPageLeftEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionPageRightEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionPageRightEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionPageRightEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionPageUpEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionPageUpEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionPageUpEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionPageDownEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionPageDownEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionPageDownEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionMoveToFirstEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionMoveToFirstEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionMoveToFirstEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionMoveToLastEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionMoveToLastEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionMoveToLastEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionReadFromTopEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionReadFromTopEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionReadFromTopEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionReadFromNextEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionReadFromNextEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionReadFromNextEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionZoomEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionZoomEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionZoomEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionReadIndicatorInformationEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionReadIndicatorInformationEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionReadIndicatorInformationEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionReadPauseResumeEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionReadPauseResumeEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionReadPauseResumeEvent();
 }
 
 bool AccessibilityAdaptor::HandleActionStartStopEvent()
 {
-  return true;//Internal::Adaptor::GetImplementation(*this).HandleActionStartStopEvent();
+  return Internal::Adaptor::GetImplementation(*this).HandleActionStartStopEvent();
 }
 
 AccessibilityAdaptor::AccessibilityAdaptor( Internal::Adaptor::AccessibilityAdaptor* adaptor )

diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h
index 5a00f8c..900f374 100644 (file)
--- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h
+++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-accessibility-adaptor.h
@@ -48,12 +48,19 @@ public: // Construction & Destruction
   AccessibilityAdaptor();
   ~AccessibilityAdaptor();
 
+public: // Mock object setup.
+
+  void MockSetReadPosition( Vector2& position );
+
 public: // Getters
+
   static AccessibilityAdaptor Get();
-  Vector2 GetReadPosition() const;
+
+  Vector2 GetReadPosition();
   bool IsEnabled() const;
   void SetActionHandler(AccessibilityActionHandler& handler);
   void SetGestureHandler(AccessibilityGestureHandler& handler);
+
   bool HandleActionNextEvent();
   bool HandleActionPreviousEvent();
   bool HandleActionActivateEvent();

diff --git a/automated-tests/src/dali-toolkit/utc-Dali-AccessibilityManager.cpp b/automated-tests/src/dali-toolkit/utc-Dali-AccessibilityManager.cpp
index 7dfe82f..d5b9f42 100644 (file)
--- a/automated-tests/src/dali-toolkit/utc-Dali-AccessibilityManager.cpp
+++ b/automated-tests/src/dali-toolkit/utc-Dali-AccessibilityManager.cpp
@@ -21,6 +21,7 @@
 // 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 <toolkit-accessibility-adaptor.h>
 
 #include <dali-toolkit/dali-toolkit.h>
 
@@ -1081,3 +1082,1064 @@ int UtcDaliAccessibilityManagerSignalFocusedActorActivated(void)
 
   END_TEST;
 }
+
+// Note: No negative test for GetReadPosition as it will always return something.
+int UtcDaliAccessibilityManagerGetReadPositionP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline(" UtcDaliAccessibilityManagerGetReadPositionP");
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  Vector2 position( 1.0f, 2.0f );
+  accessibilityAdaptor.MockSetReadPosition( position );
+
+  DALI_TEST_EQUALS( manager.GetReadPosition(), position, TEST_LOCATION );
+
+  END_TEST;
+}
+
+// Functor to test if an accessibility signal has been called.
+class AccessibilityManagerSignalHandler : public Dali::ConnectionTracker
+{
+public:
+  AccessibilityManagerSignalHandler() :
+    mCalls( 0 )
+  {
+  }
+
+  bool Callback( AccessibilityManager& accessibilityManager )
+  {
+    mCalls++;
+    tet_infoline( "Signal called" );
+    return true;
+  }
+
+  unsigned int GetCalls() const
+  {
+    return mCalls;
+  }
+
+private:
+  unsigned int mCalls;  ///< Keeps track of how many times the signal has been called.
+};
+
+int UtcDaliAccessibilityManagerStatusChangedSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerStatusChangedSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.StatusChangedSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  // Cause a state change.
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionEnableEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerStatusChangedSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerStatusChangedSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.StatusChangedSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionNextSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionNextSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionNextEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionNextSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionNextSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionPreviousSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionPreviousSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionPreviousEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionPreviousSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionPreviousSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionActivateSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionActivateSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionActivateSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionActivateEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionActivateSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionActivateSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionActivateSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionReadEvent( 100.0f, 200.0f, true );
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionOverSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionOverSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionOverSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  // Note that the ActionOverSignal is provoked by a read even when "allow read again" is set to false.
+  accessibilityAdaptor.HandleActionReadEvent( 100.0f, 200.0f, false );
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionOverSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionOverSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionOverSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadNextSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadNextSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionReadNextEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadNextSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadNextSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadPreviousSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadPreviousSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionReadPreviousEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadPreviousSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadPreviousSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionUpSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionUpSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionUpEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionUpSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionUpSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionDownSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionDownSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionDownEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionDownSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionDownSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionClearFocusSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionClearFocusSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionClearFocusSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionClearFocusEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionClearFocusSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionClearFocusSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionClearFocusSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionBackSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionBackSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionBackSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionBackEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionBackSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionBackSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionBackSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionScrollUpSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionScrollUpSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionScrollUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionScrollUpEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionScrollUpSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionScrollUpSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionScrollUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionScrollDownSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionScrollDownSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionScrollDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionScrollDownEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionScrollDownSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionScrollDownSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionScrollDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionPageLeftSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionPageLeftSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionPageLeftSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionPageLeftEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionPageLeftSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionPageLeftSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionPageLeftSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionPageRightSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionPageRightSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionPageRightSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionPageRightEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionPageRightSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionPageRightSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionPageRightSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionPageUpSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionPageUpSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionPageUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionPageUpEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionPageUpSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionPageUpSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionPageUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionPageDownSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionPageDownSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionPageDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionPageDownEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionPageDownSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionPageDownSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionPageDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionMoveToFirstSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionMoveToFirstSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionMoveToFirstSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionMoveToFirstEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionMoveToFirstSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionMoveToFirstSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionMoveToFirstSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionMoveToLastSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionMoveToLastSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionMoveToLastSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionMoveToLastEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionMoveToLastSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionMoveToLastSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionMoveToLastSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadFromTopSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadFromTopSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadFromTopSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionReadFromTopEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadFromTopSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadFromTopSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadFromTopSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadFromNextSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadFromNextSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadFromNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionReadFromNextEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadFromNextSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadFromNextSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadFromNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionZoomSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionZoomSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionZoomSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionZoomEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionZoomSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionZoomSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionZoomSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadIndicatorInformationSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadIndicatorInformationSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadIndicatorInformationSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionReadIndicatorInformationEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadIndicatorInformationSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadIndicatorInformationSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadIndicatorInformationSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadPauseResumeSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadPauseResumeSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadPauseResumeSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionReadPauseResumeEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionReadPauseResumeSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionReadPauseResumeSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionReadPauseResumeSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionStartStopSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionStartStopSignalP" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionStartStopSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+  accessibilityAdaptor.HandleActionStartStopEvent();
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionStartStopSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionStartStopSignalN" );
+
+  AccessibilityManagerSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionStartStopSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}
+
+// Functor to test if a accessibility scroll signal has been called.
+class AccessibilityManagerScrollSignalHandler : public Dali::ConnectionTracker
+{
+public:
+  AccessibilityManagerScrollSignalHandler() :
+    mCalls( 0 )
+  {
+  }
+
+  bool Callback( AccessibilityManager& accessibilityManager, const Dali::TouchEvent& touchEvent )
+  {
+    mCalls++;
+    mTouchEvent = touchEvent;
+    tet_infoline( "Signal called" );
+    return true;
+  }
+
+  unsigned int GetCalls() const
+  {
+    return mCalls;
+  }
+
+  const Dali::TouchEvent& GetTouchEvent() const
+  {
+    return mTouchEvent;
+  }
+
+private:
+  unsigned int mCalls;         ///< Keeps track of how many times the signal has been called.
+  Dali::TouchEvent mTouchEvent; ///< Stores the last touch event received.
+};
+
+int UtcDaliAccessibilityManagerActionScrollSignalP(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionScrollSignalP" );
+
+  AccessibilityManagerScrollSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionScrollSignal().Connect( &callback, &AccessibilityManagerScrollSignalHandler::Callback );
+
+  Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
+
+  TouchPoint point( 0, TouchPoint::Started, 100.0f, 200.0f );
+  accessibilityAdaptor.HandleActionScrollEvent( point, 0u );
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
+
+  const TouchEvent& signalTouchEvent = callback.GetTouchEvent();
+  DALI_TEST_EQUALS( signalTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
+
+  const TouchPoint& signalTouchPoint = signalTouchEvent.GetPoint( 0u );
+
+  DALI_TEST_EQUALS( signalTouchPoint.state, TouchPoint::Started, TEST_LOCATION );
+  DALI_TEST_EQUALS( signalTouchPoint.screen.x, 100.0f, TEST_LOCATION );
+  DALI_TEST_EQUALS( signalTouchPoint.screen.y, 200.0f, TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliAccessibilityManagerActionScrollSignalN(void)
+{
+  ToolkitTestApplication application;
+  tet_infoline( " UtcDaliAccessibilityManagerActionScrollSignalN" );
+
+  AccessibilityManagerScrollSignalHandler callback;
+
+  AccessibilityManager manager = AccessibilityManager::Get();
+  DALI_TEST_CHECK( manager );
+
+  manager.ActionScrollSignal().Connect( &callback, &AccessibilityManagerScrollSignalHandler::Callback );
+
+  DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
+
+  END_TEST;
+}