automated-tests/src/dali-toolkit/utc-Dali-AccessibilityManager.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <iostream>
  19 #include <stdlib.h>
  20
  21 #include <dali-toolkit/dali-toolkit.h>
  22
  23 #include <dali-toolkit-test-suite-utils.h>
  24 #include <toolkit-accessibility-adaptor.h>
  25 #include <dummy-control.h>
  26
  27 using namespace Dali;
  28 using namespace Toolkit;
  29
  30
  31 void utc_dali_toolkit_accessibility_manager_startup(void)
  32 {
  33   test_return_value = TET_UNDEF;
  34 }
  35
  36 void utc_dali_toolkit_accessibility_manager_cleanup(void)
  37 {
  38   test_return_value = TET_PASS;
  39 }
  40
  41
  42 namespace
  43 {
  44
  45 static bool gObjectCreatedCallBackCalled;
  46
  47 static void TestCallback(BaseHandle handle)
  48 {
  49   gObjectCreatedCallBackCalled = true;
  50 }
  51
  52 // Functors to test whether focus changed signal is emitted when the focus is changed
  53 class FocusChangedCallback : public Dali::ConnectionTracker
  54 {
  55 public:
  56   FocusChangedCallback(bool& signalReceived)
  57   : mSignalVerified(signalReceived),
  58     mOriginalFocusedActor(),
  59     mCurrentFocusedActor()
  60   {
  61   }
  62
  63   void Callback(Actor originalFocusedActor, Actor currentFocusedActor)
  64   {
  65     tet_infoline("Verifying FocusChangedCallback()");
  66
  67     if(originalFocusedActor == mCurrentFocusedActor)
  68     {
  69       mSignalVerified = true;
  70     }
  71
  72     mOriginalFocusedActor = originalFocusedActor;
  73     mCurrentFocusedActor = currentFocusedActor;
  74   }
  75
  76   void Reset()
  77   {
  78     mSignalVerified = false;
  79   }
  80
  81   bool& mSignalVerified;
  82   Actor mOriginalFocusedActor;
  83   Actor mCurrentFocusedActor;
  84 };
  85
  86 // Functors to test whether focus overshot signal is emitted when there is no way to move focus further.
  87 class FocusOvershotCallback : public Dali::ConnectionTracker
  88 {
  89 public:
  90   FocusOvershotCallback(bool& signalReceived)
  91   : mSignalVerified(signalReceived),
  92     mCurrentFocusedActor(),
  93     mFocusOvershotDirection(Toolkit::AccessibilityManager::OVERSHOT_NEXT)
  94   {
  95   }
  96
  97   void Callback(Actor currentFocusedActor, Toolkit::AccessibilityManager::FocusOvershotDirection direction)
  98   {
  99     tet_infoline("Verifying FocusOvershotCallback()");
 100
 101     if(currentFocusedActor == mCurrentFocusedActor && direction == mFocusOvershotDirection)
 102     {
 103       mSignalVerified = true;
 104     }
 105   }
 106
 107   void Reset()
 108   {
 109     mSignalVerified = false;
 110   }
 111
 112   bool& mSignalVerified;
 113   Actor mCurrentFocusedActor;
 114   Toolkit::AccessibilityManager::FocusOvershotDirection mFocusOvershotDirection;
 115 };
 116
 117 // Functor to test whether focused actor activated signal is emitted.
 118 class FocusedActorActivatedCallback : public Dali::ConnectionTracker
 119 {
 120 public:
 121   FocusedActorActivatedCallback()
 122   {
 123   }
 124
 125   void Callback(Actor activatedActor)
 126   {
 127     tet_infoline("Verifying FocusedActorActivatedCallback()");
 128   }
 129 };
 130
 131 } // namespace
 132
 133
 134 int UtcDaliAccessibilityManagerGet(void)
 135 {
 136   ToolkitTestApplication application;
 137
 138   tet_infoline(" UtcDaliAccessibilityManagerGet");
 139
 140   AccessibilityManager manager;
 141
 142   //Ensure object is created by checking if it's registered
 143   ObjectRegistry registry = Stage::GetCurrent().GetObjectRegistry();
 144   DALI_TEST_CHECK(registry);
 145
 146   gObjectCreatedCallBackCalled = false;
 147   registry.ObjectCreatedSignal().Connect( &TestCallback );
 148   {
 149     manager = AccessibilityManager::Get();
 150     DALI_TEST_CHECK(manager);
 151   }
 152   DALI_TEST_CHECK( gObjectCreatedCallBackCalled );
 153
 154   AccessibilityManager newManager = AccessibilityManager::Get();
 155   DALI_TEST_CHECK(newManager);
 156
 157   // Check that accessibility manager is a singleton
 158   DALI_TEST_CHECK(manager == newManager);
 159   END_TEST;
 160 }
 161
 162 int UtcDaliAccessibilityManagerSetAndGetAccessibilityAttribute(void)
 163 {
 164   ToolkitTestApplication application;
 165
 166   tet_infoline(" UtcDaliAccessibilityManagerSetAndGetAccessibilityAttribute");
 167
 168   AccessibilityManager manager = AccessibilityManager::Get();
 169   DALI_TEST_CHECK(manager);
 170
 171   Actor actor = Actor::New();
 172   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, AccessibilityManager::ACCESSIBILITY_LABEL) == "");
 173
 174   manager.SetAccessibilityAttribute(actor, AccessibilityManager::ACCESSIBILITY_LABEL, "Description");
 175   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, AccessibilityManager::ACCESSIBILITY_LABEL) == "Description");
 176
 177   manager.SetAccessibilityAttribute(actor, AccessibilityManager::ACCESSIBILITY_LABEL, "New description");
 178   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(actor, AccessibilityManager::ACCESSIBILITY_LABEL) == "New description");
 179   END_TEST;
 180 }
 181
 182 int UtcDaliAccessibilityManagerSetAndGetFocusOrder(void)
 183 {
 184   ToolkitTestApplication application;
 185
 186   tet_infoline(" UtcDaliAccessibilityManagerSetAndGetFocusOrder");
 187
 188   AccessibilityManager manager = AccessibilityManager::Get();
 189   DALI_TEST_CHECK(manager);
 190
 191   Actor first = Actor::New();
 192   Actor second = Actor::New();
 193   DALI_TEST_CHECK(manager.GetFocusOrder(first) == 0);
 194   DALI_TEST_CHECK(manager.GetFocusOrder(second) == 0);
 195
 196   // Set the focus order and description for the first actor
 197   manager.SetFocusOrder(first, 1);
 198   manager.SetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
 199   DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
 200   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 201
 202   // Set the focus order and description for the second actor
 203   manager.SetFocusOrder(second, 2);
 204   manager.SetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL, "second");
 205   DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
 206   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
 207
 208   // check that the focus order of the first actor is changed
 209   manager.SetFocusOrder(first, 2);
 210   DALI_TEST_CHECK(manager.GetFocusOrder(first) == 2);
 211   // make sure the change of focus order doesn't affect the actor's description
 212   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 213
 214   // check that the focus order of the second actor is increased to 3
 215   DALI_TEST_CHECK(manager.GetFocusOrder(second) == 3);
 216   // make sure the change of focus order doesn't affect the actor's description
 217   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
 218
 219   // check that the focus order of the second actor is changed to 1
 220   manager.SetFocusOrder(second, 1);
 221   DALI_TEST_CHECK(manager.GetFocusOrder(second) == 1);
 222   // make sure the change of focus order doesn't affect the actor's description
 223   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
 224
 225   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
 226   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
 227   accAdaptor.HandleActionEnableEvent();
 228
 229   // Set the focus order and description for the third actor
 230   Actor third = Actor::New();
 231   manager.SetFocusOrder(third, 1);
 232   manager.SetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL, "third");
 233   DALI_TEST_CHECK(manager.GetFocusOrder(third) == 1);
 234   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 235
 236   // check that the focus order of the second actor is increased to 2.
 237   DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
 238   // make sure the change of focus order doesn't affect the actor's description
 239   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
 240
 241   // check that the focus order of the first actor is increased to 3.
 242   DALI_TEST_CHECK(manager.GetFocusOrder(first) == 3);
 243   // make sure the change of focus order doesn't affect the actor's description
 244   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 245   END_TEST;
 246 }
 247
 248 int UtcDaliAccessibilityManagerGenerateNewFocusOrder(void)
 249 {
 250   ToolkitTestApplication application;
 251
 252   tet_infoline(" UtcDaliAccessibilityManagerGenerateNewFocusOrder");
 253
 254   AccessibilityManager manager = AccessibilityManager::Get();
 255   DALI_TEST_CHECK(manager);
 256
 257   DALI_TEST_CHECK(1 == manager.GenerateNewFocusOrder());
 258   DALI_TEST_CHECK(1 == manager.GenerateNewFocusOrder());
 259
 260   Actor first = Actor::New();
 261   Actor second = Actor::New();
 262
 263   // Set the focus order for the first actor
 264   manager.SetFocusOrder(first, 1);
 265   manager.SetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
 266   DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
 267
 268   //Test for new focus order
 269   DALI_TEST_CHECK(2 == manager.GenerateNewFocusOrder());
 270
 271   // Set the focus order for the first actor
 272   manager.SetFocusOrder(second, 2);
 273   manager.SetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
 274   DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
 275   END_TEST;
 276 }
 277
 278 int UtcDaliAccessibilityManagerGetActorByFocusOrder(void)
 279 {
 280   ToolkitTestApplication application;
 281
 282   tet_infoline(" UtcDaliAccessibilityManagerGetActorByFocusOrder");
 283
 284   AccessibilityManager manager = AccessibilityManager::Get();
 285   DALI_TEST_CHECK(manager);
 286
 287   // Create the actors and set their focus orders
 288   Actor first = Actor::New();
 289   manager.SetFocusOrder(first, 1);
 290
 291   Actor second = Actor::New();
 292   manager.SetFocusOrder(second, 2);
 293
 294   Actor third = Actor::New();
 295   manager.SetFocusOrder(third, 3);
 296
 297   // Check that we get an empty handle as no actor is added to the stage yet.
 298   DALI_TEST_CHECK(manager.GetActorByFocusOrder(1) == Actor());
 299   DALI_TEST_CHECK(manager.GetActorByFocusOrder(2) == Actor());
 300   DALI_TEST_CHECK(manager.GetActorByFocusOrder(3) == Actor());
 301
 302   // Add the actors to the stage
 303   Stage::GetCurrent().Add(first);
 304   Stage::GetCurrent().Add(second);
 305   Stage::GetCurrent().Add(third);
 306
 307   // Check that we get an empty handle because focus order 0 means undefined.
 308   DALI_TEST_CHECK(manager.GetActorByFocusOrder(0) == Actor());
 309
 310   // Check that we get correct actors for the specified focus orders
 311   DALI_TEST_CHECK(manager.GetActorByFocusOrder(1) == first);
 312   DALI_TEST_CHECK(manager.GetActorByFocusOrder(2) == second);
 313   DALI_TEST_CHECK(manager.GetActorByFocusOrder(3) == third);
 314
 315   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
 316   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
 317   accAdaptor.HandleActionEnableEvent();
 318
 319   // Change the focus order of the third actor to 1
 320   manager.SetFocusOrder(third, 1);
 321
 322   // Check that we still get correct actors after changing their focus orders
 323   DALI_TEST_CHECK(manager.GetActorByFocusOrder(1) == third);
 324   DALI_TEST_CHECK(manager.GetActorByFocusOrder(2) == first);
 325   DALI_TEST_CHECK(manager.GetActorByFocusOrder(3) == second);
 326
 327   // Check that we get an empty handle because no actor has a focus order of 4
 328   DALI_TEST_CHECK(manager.GetActorByFocusOrder(4) == Actor());
 329   END_TEST;
 330 }
 331
 332 int UtcDaliAccessibilityManagerSetAndGetCurrentFocusActor(void)
 333 {
 334   ToolkitTestApplication application;
 335
 336   tet_infoline(" UtcDaliAccessibilityManagerSetAndGetCurrentFocusActor");
 337
 338   AccessibilityManager manager = AccessibilityManager::Get();
 339   DALI_TEST_CHECK(manager);
 340
 341   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
 342   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
 343   accAdaptor.HandleActionEnableEvent();
 344
 345   // Create the first actor and add it to the stage
 346   Actor first = Actor::New();
 347   manager.SetFocusOrder(first, 1);
 348   Stage::GetCurrent().Add(first);
 349
 350   // Create the second actor and add it to the stage
 351   Actor second = Actor::New();
 352   manager.SetFocusOrder(second, 2);
 353   Stage::GetCurrent().Add(second);
 354
 355   // Create the third actor but don't add it to the stage
 356   Actor third = Actor::New();
 357   manager.SetFocusOrder(third, 3);
 358
 359   // Check that no actor is being focused yet.
 360   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
 361
 362   // Check that it will fail to set focus on an invalid actor
 363   DALI_TEST_CHECK(manager.SetCurrentFocusActor(Actor()) == false);
 364
 365   // Check that the focus is set on the first actor
 366   DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
 367   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
 368
 369   // Check that the focus is set on the second actor
 370   DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
 371   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
 372
 373   // Check that it will fail to set focus on the third actor as it's not in the stage
 374   DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == false);
 375
 376   // Add the third actor to the stage
 377   Stage::GetCurrent().Add(third);
 378
 379   // make the third actor invisible
 380   third.SetVisible(false);
 381   // flush the queue and render once
 382   application.SendNotification();
 383   application.Render();
 384
 385   // Check that it will fail to set focus on the third actor as it's invisible
 386   DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == false);
 387
 388   // Make the third actor visible
 389   third.SetVisible(true);
 390   // flush the queue and render once
 391   application.SendNotification();
 392   application.Render();
 393
 394   // Make the third actor not focusable
 395   Property::Index propertyActorFocusable = third.GetPropertyIndex("focusable");
 396   third.SetProperty(propertyActorFocusable, false);
 397   // flush the queue and render once
 398   application.SendNotification();
 399   application.Render();
 400
 401   // Check that it will fail to set focus on the third actor as it's not focusable
 402   DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == false);
 403
 404   // Make the third actor focusable
 405   third.SetProperty(propertyActorFocusable, true);
 406   // flush the queue and render once
 407   application.SendNotification();
 408   application.Render();
 409
 410   // Check that the focus is successfully moved to the third actor
 411   DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == true);
 412
 413   // Make the current focused actor to be not focusable by setting its focus order to be 0
 414   manager.SetFocusOrder(third, 0);
 415
 416   // Check that the focus is automatically cleared
 417   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
 418
 419   // Set the focus order of the third actor again
 420   manager.SetFocusOrder(third, 3);
 421
 422   // Check that the third actor can be focused successfully now
 423   DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == true);
 424   END_TEST;
 425 }
 426
 427 int UtcDaliAccessibilityManagerGetCurrentFocusGroup(void)
 428 {
 429   ToolkitTestApplication application;
 430
 431   tet_infoline(" UtcDaliAccessibilityManagerGetCurrentFocusGroup");
 432
 433   AccessibilityManager manager = AccessibilityManager::Get();
 434   DALI_TEST_CHECK(manager);
 435
 436   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
 437   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
 438   accAdaptor.HandleActionEnableEvent();
 439
 440   // Create an actor with two child actors and add it to the stage
 441   Actor parent = Actor::New();
 442   Actor firstChild = Actor::New();
 443   Actor secondChild = Actor::New();
 444   parent.Add(firstChild);
 445   parent.Add(secondChild);
 446   Stage::GetCurrent().Add(parent);
 447
 448   // Create three actors and add them as the children of the first child actor
 449   Actor firstGrandChild = Actor::New();
 450   Actor secondGrandChild = Actor::New();
 451   Actor thirdGrandChild = Actor::New();
 452   firstChild.Add(firstGrandChild);
 453   firstChild.Add(secondGrandChild);
 454   firstChild.Add(thirdGrandChild);
 455
 456   // Set focus order to the actors
 457   manager.SetFocusOrder(parent, 1);
 458   manager.SetFocusOrder(firstChild, 2);
 459   manager.SetFocusOrder(firstGrandChild, 3);
 460   manager.SetFocusOrder(secondGrandChild, 4);
 461   manager.SetFocusOrder(thirdGrandChild, 5);
 462   manager.SetFocusOrder(secondChild, 6);
 463
 464   // Set the parent and the first child actor as focus groups
 465   manager.SetFocusGroup(parent, true);
 466   DALI_TEST_CHECK(manager.IsFocusGroup(parent) == true);
 467
 468   // Set focus to the first grand child actor
 469   DALI_TEST_CHECK(manager.SetCurrentFocusActor(firstGrandChild) == true);
 470   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstGrandChild);
 471
 472   // The current focus group should be the parent, As it is the immediate parent which is also a focus group.
 473   DALI_TEST_CHECK(manager.GetCurrentFocusGroup() == parent);
 474
 475   manager.SetFocusGroup(firstChild, true);
 476   DALI_TEST_CHECK(manager.IsFocusGroup(firstChild) == true);
 477
 478   // The current focus group should be the firstChild, As it is the immediate parent which is also a focus group.
 479   DALI_TEST_CHECK(manager.GetCurrentFocusGroup() == firstChild);
 480
 481   manager.SetFocusGroup(firstGrandChild, true);
 482   DALI_TEST_CHECK(manager.IsFocusGroup(firstGrandChild) == true);
 483
 484   // The current focus group should be itself, As it is also a focus group.
 485   DALI_TEST_CHECK(manager.GetCurrentFocusGroup() == firstGrandChild);
 486
 487   // Set focus to the second grand child actor
 488   DALI_TEST_CHECK(manager.SetCurrentFocusActor(secondGrandChild) == true);
 489   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == secondGrandChild);
 490
 491   // The current focus group should be the firstChild, As it is the immediate parent which is also a
 492   // focus group for the current focus actor.
 493   DALI_TEST_CHECK(manager.GetCurrentFocusGroup() == firstChild);
 494
 495   END_TEST;
 496 }
 497
 498 int UtcDaliAccessibilityManagerGetCurrentFocusOrder(void)
 499 {
 500   ToolkitTestApplication application;
 501
 502   tet_infoline(" UtcDaliAccessibilityManagerGetCurrentFocusOrder");
 503
 504   AccessibilityManager manager = AccessibilityManager::Get();
 505   DALI_TEST_CHECK(manager);
 506
 507   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
 508   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
 509   accAdaptor.HandleActionEnableEvent();
 510
 511   Actor first = Actor::New();
 512   Stage::GetCurrent().Add(first);
 513
 514   Actor second = Actor::New();
 515   Stage::GetCurrent().Add(second);
 516
 517   Actor third = Actor::New();
 518   Stage::GetCurrent().Add(third);
 519
 520   // Set the focus order and description for the first actor
 521   manager.SetFocusOrder(first, 1);
 522   manager.SetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
 523   DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
 524   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 525
 526   // Set the focus order and description for the second actor
 527   manager.SetFocusOrder(second, 2);
 528   manager.SetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL, "second");
 529   DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
 530   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
 531
 532   // Set the focus order and description for the second actor
 533   manager.SetFocusOrder(third, 3);
 534   manager.SetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL, "third");
 535   DALI_TEST_CHECK(manager.GetFocusOrder(third) == 3);
 536   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 537
 538   // Check that no actor is being focused yet.
 539   DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 0);
 540
 541   // Set the focus on the first actor and test
 542   DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
 543   DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 1);
 544
 545   // Move the focus forward to the second actor and test
 546   manager.MoveFocusForward();
 547   DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 2);
 548
 549   // Move the focus forward to the third actor and test
 550   manager.MoveFocusForward();
 551   DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 3);
 552
 553   // Clear focus and test
 554   manager.ClearFocus();
 555   DALI_TEST_CHECK(manager.GetCurrentFocusOrder() == 0);
 556   END_TEST;
 557 }
 558
 559 int UtcDaliAccessibilityManagerMoveFocusForward(void)
 560 {
 561   ToolkitTestApplication application;
 562
 563   tet_infoline(" UtcDaliAccessibilityManagerMoveFocusForward");
 564
 565   AccessibilityManager manager = AccessibilityManager::Get();
 566   DALI_TEST_CHECK(manager);
 567
 568   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
 569   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
 570   accAdaptor.HandleActionEnableEvent();
 571
 572   Actor first = Actor::New();
 573   Stage::GetCurrent().Add(first);
 574
 575   Actor second = Actor::New();
 576   Stage::GetCurrent().Add(second);
 577
 578   Actor third = Actor::New();
 579   Stage::GetCurrent().Add(third);
 580
 581   // Set the focus order and description for the first actor
 582   manager.SetFocusOrder(first, 1);
 583   manager.SetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
 584   DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
 585   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 586
 587   // Set the focus order and description for the second actor
 588   manager.SetFocusOrder(second, 2);
 589   manager.SetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL, "second");
 590   DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
 591   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
 592
 593   // Set the focus order and description for the second actor
 594   manager.SetFocusOrder(third, 3);
 595   manager.SetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL, "third");
 596   DALI_TEST_CHECK(manager.GetFocusOrder(third) == 3);
 597   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 598
 599   // Check that no actor is being focused yet.
 600   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
 601
 602   // Set the focus on the first actor
 603   DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
 604   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
 605   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 606
 607   // Test the non-wrapped move first
 608   manager.SetWrapMode(false);
 609   DALI_TEST_CHECK(manager.GetWrapMode() == false);
 610
 611   // Move the focus forward to the second actor
 612   manager.MoveFocusForward();
 613   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
 614   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
 615
 616   // Move the focus forward to the third actor
 617   manager.MoveFocusForward();
 618   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
 619   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 620
 621   // Check that it will fail to move the focus forward again as the third actor is the last
 622   // focusable actor in the focus chain
 623   manager.MoveFocusForward();
 624   // The focus should still be set on the third actor
 625   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
 626   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 627
 628   // Now test the wrapped move
 629   manager.SetWrapMode(true);
 630   DALI_TEST_CHECK(manager.GetWrapMode() == true);
 631
 632   // Move the focus forward recursively and this time the first actor should be focused
 633   manager.MoveFocusForward();
 634   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
 635   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 636
 637   // Make the second actor not focusable
 638   Property::Index propertyActorFocusable = second.GetPropertyIndex("focusable");
 639   second.SetProperty(propertyActorFocusable, false);
 640   // flush the queue and render once
 641   application.SendNotification();
 642   application.Render();
 643
 644   // Move the focus forward and check that the second actor should be skipped and
 645   // the third actor should be focused now.
 646   manager.MoveFocusForward();
 647   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
 648   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 649
 650   // Make the first actor invisible
 651   first.SetVisible(false);
 652   // flush the queue and render once
 653   application.SendNotification();
 654   application.Render();
 655
 656   // Move the focus forward and check that the first actor should be skipped as it's
 657   // invisible and the second actor should also be skipped as it's not focusable,
 658   // so the focus will still be on the third actor
 659   manager.MoveFocusForward();
 660   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
 661   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 662
 663   // Make the third actor invisible so that no actor can be focused.
 664   third.SetVisible(false);
 665   // flush the queue and render once
 666   application.SendNotification();
 667   application.Render();
 668
 669   // Check that the focus move is failed as all the three actors can not be focused
 670   manager.MoveFocusForward();
 671   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
 672   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 673   END_TEST;
 674 }
 675
 676 int UtcDaliAccessibilityManagerMoveFocusBackward(void)
 677 {
 678   ToolkitTestApplication application;
 679
 680   tet_infoline(" UtcDaliAccessibilityManagerMoveFocusBackward");
 681
 682   AccessibilityManager manager = AccessibilityManager::Get();
 683   DALI_TEST_CHECK(manager);
 684
 685   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
 686   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
 687   accAdaptor.HandleActionEnableEvent();
 688
 689   Actor first = Actor::New();
 690   Stage::GetCurrent().Add(first);
 691
 692   Actor second = Actor::New();
 693   Stage::GetCurrent().Add(second);
 694
 695   Actor third = Actor::New();
 696   Stage::GetCurrent().Add(third);
 697
 698   // Set the focus order and description for the first actor
 699   manager.SetFocusOrder(first, 1);
 700   manager.SetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL, "first");
 701   DALI_TEST_CHECK(manager.GetFocusOrder(first) == 1);
 702   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(first, AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 703
 704   // Set the focus order and description for the second actor
 705   manager.SetFocusOrder(second, 2);
 706   manager.SetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL, "second");
 707   DALI_TEST_CHECK(manager.GetFocusOrder(second) == 2);
 708   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(second, AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
 709
 710   // Set the focus order and description for the second actor
 711   manager.SetFocusOrder(third, 3);
 712   manager.SetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL, "third");
 713   DALI_TEST_CHECK(manager.GetFocusOrder(third) == 3);
 714   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(third, AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 715
 716   // Check that no actor is being focused yet.
 717   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
 718
 719   // Set the focus on the third actor
 720   DALI_TEST_CHECK(manager.SetCurrentFocusActor(third) == true);
 721   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
 722   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 723
 724   // Test the non-wrapped move first
 725   manager.SetWrapMode(false);
 726   DALI_TEST_CHECK(manager.GetWrapMode() == false);
 727
 728   // Move the focus backward to the second actor
 729   manager.MoveFocusBackward();
 730   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
 731   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "second");
 732
 733   // Move the focus backward to the first actor
 734   manager.MoveFocusBackward();
 735   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
 736   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 737
 738   // Check that it will fail to move the focus backward again as the first actor is the first
 739   // focusable actor in the focus chain
 740   manager.MoveFocusBackward();
 741   // The focus should still be set on the first actor
 742   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
 743   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 744
 745   // Now test the wrapped move
 746   manager.SetWrapMode(true);
 747   DALI_TEST_CHECK(manager.GetWrapMode() == true);
 748
 749   // Move the focus backward recursively and this time the third actor should be focused
 750   manager.MoveFocusBackward();
 751   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == third);
 752   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "third");
 753
 754   // Make the second actor not focusable
 755   Property::Index propertyActorFocusable = second.GetPropertyIndex("focusable");
 756   second.SetProperty(propertyActorFocusable, false);
 757   // flush the queue and render once
 758   application.SendNotification();
 759   application.Render();
 760
 761   // Move the focus backward and check that the second actor should be skipped and
 762   // the first actor should be focused now.
 763   manager.MoveFocusBackward();
 764   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
 765   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 766
 767   // Make the third actor invisible
 768   third.SetVisible(false);
 769   // flush the queue and render once
 770   application.SendNotification();
 771   application.Render();
 772
 773   // Move the focus backward and check that the third actor should be skipped as it's
 774   // invisible and the second actor should also be skipped as it's not focusable,
 775   // so the focus will still be on the first actor
 776   manager.MoveFocusBackward();
 777   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
 778   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 779
 780   // Make the first actor invisible so that no actor can be focused.
 781   first.SetVisible(false);
 782   // flush the queue and render once
 783   application.SendNotification();
 784   application.Render();
 785
 786   // Check that the focus move is failed as all the three actors can not be focused
 787   manager.MoveFocusBackward();
 788   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
 789   DALI_TEST_CHECK(manager.GetAccessibilityAttribute(manager.GetCurrentFocusActor(), AccessibilityManager::ACCESSIBILITY_LABEL) == "first");
 790   END_TEST;
 791 }
 792
 793 int UtcDaliAccessibilityManagerClearFocus(void)
 794 {
 795   ToolkitTestApplication application;
 796
 797   tet_infoline(" UtcDaliAccessibilityManagerClearFocus");
 798
 799   AccessibilityManager manager = AccessibilityManager::Get();
 800   DALI_TEST_CHECK(manager);
 801
 802   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
 803   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
 804   accAdaptor.HandleActionEnableEvent();
 805
 806   // Create the first actor and add it to the stage
 807   Actor first = Actor::New();
 808   manager.SetFocusOrder(first, 1);
 809   Stage::GetCurrent().Add(first);
 810
 811   // Create the second actor and add it to the stage
 812   Actor second = Actor::New();
 813   manager.SetFocusOrder(second, 2);
 814   Stage::GetCurrent().Add(second);
 815
 816   // Check that no actor is being focused yet.
 817   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
 818
 819   // Check that the focus is set on the first actor
 820   DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
 821   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
 822
 823   // Check that the focus is set on the second actor
 824   DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
 825   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
 826
 827   // Clear the focus
 828   manager.ClearFocus();
 829
 830   // Check that no actor is being focused now.
 831   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
 832   END_TEST;
 833 }
 834
 835 int UtcDaliAccessibilityManagerReset(void)
 836 {
 837   ToolkitTestApplication application;
 838
 839   tet_infoline(" UtcDaliAccessibilityManagerReset");
 840
 841   AccessibilityManager manager = AccessibilityManager::Get();
 842   DALI_TEST_CHECK(manager);
 843
 844   // Create the first actor and add it to the stage
 845   Actor first = Actor::New();
 846   manager.SetFocusOrder(first, 1);
 847   Stage::GetCurrent().Add(first);
 848
 849   // Create the second actor and add it to the stage
 850   Actor second = Actor::New();
 851   manager.SetFocusOrder(second, 2);
 852   Stage::GetCurrent().Add(second);
 853
 854   // Check that no actor is being focused yet.
 855   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
 856
 857   // Check that the focus is set on the first actor
 858   DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
 859   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
 860
 861   // Check that the focus is set on the second actor
 862   DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
 863   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
 864
 865   // Clear the focus
 866   manager.Reset();
 867
 868   // Check that no actor is being focused now and the focus order of actors have been cleared
 869   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
 870   DALI_TEST_CHECK(manager.GetFocusOrder(first) == 0);
 871   DALI_TEST_CHECK(manager.GetFocusOrder(first) == 0);
 872   END_TEST;
 873 }
 874
 875 int UtcDaliAccessibilityManagerFocusGroup(void)
 876 {
 877   ToolkitTestApplication application;
 878
 879   tet_infoline(" UtcDaliAccessibilityManagerFocusGroup");
 880
 881   AccessibilityManager manager = AccessibilityManager::Get();
 882   DALI_TEST_CHECK(manager);
 883
 884   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
 885   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
 886   accAdaptor.HandleActionEnableEvent();
 887
 888   // Create an actor with two child actors and add it to the stage
 889   Actor parent = Actor::New();
 890   Actor firstChild = Actor::New();
 891   Actor secondChild = Actor::New();
 892   parent.Add(firstChild);
 893   parent.Add(secondChild);
 894   Stage::GetCurrent().Add(parent);
 895
 896   // Create three actors and add them as the children of the first child actor
 897   Actor firstGrandChild = Actor::New();
 898   Actor secondGrandChild = Actor::New();
 899   Actor thirdGrandChild = Actor::New();
 900   firstChild.Add(firstGrandChild);
 901   firstChild.Add(secondGrandChild);
 902   firstChild.Add(thirdGrandChild);
 903
 904   // Set focus order to the actors
 905   manager.SetFocusOrder(parent, 1);
 906   manager.SetFocusOrder(firstChild, 2);
 907   manager.SetFocusOrder(firstGrandChild, 3);
 908   manager.SetFocusOrder(secondGrandChild, 4);
 909   manager.SetFocusOrder(thirdGrandChild, 5);
 910   manager.SetFocusOrder(secondChild, 6);
 911
 912   // Set the parent and the first child actor as focus groups
 913   manager.SetFocusGroup(parent, true);
 914   DALI_TEST_CHECK(manager.IsFocusGroup(parent) == true);
 915
 916   // The focus group of the parent should be itself, as it is set to be a focus group.
 917   DALI_TEST_CHECK(manager.GetFocusGroup(parent) == parent);
 918
 919   // The focus group of the firstChild should be its parent, as it is the immediate parent which is also a group.
 920   DALI_TEST_CHECK(manager.GetFocusGroup(firstChild) == parent);
 921
 922   manager.SetFocusGroup(firstChild, true);
 923   DALI_TEST_CHECK(manager.IsFocusGroup(firstChild) == true);
 924
 925   // The focus group of the firstChild should be itself, as it is set to be a focus group now.
 926   DALI_TEST_CHECK(manager.GetFocusGroup(firstChild) == firstChild);
 927
 928   // Enable wrap mode for focus movement.
 929   manager.SetWrapMode(true);
 930   DALI_TEST_CHECK(manager.GetWrapMode() == true);
 931
 932   // Check that no actor is being focused yet.
 933   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
 934
 935   // Check that the focus is set on the parent actor.
 936   DALI_TEST_CHECK(manager.SetCurrentFocusActor(parent) == true);
 937   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == parent);
 938
 939   // Check that group mode is disabled.
 940   DALI_TEST_CHECK(manager.GetGroupMode() == false);
 941
 942   // Check that the focus movement is wrapped as normal.
 943   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 944   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstChild);
 945   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 946   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstGrandChild);
 947   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 948   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == secondGrandChild);
 949   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 950   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == thirdGrandChild);
 951   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 952   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == secondChild);
 953   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 954   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == parent);
 955   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 956   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstChild);
 957   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 958   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstGrandChild);
 959
 960   // Enable the group mode.
 961   manager.SetGroupMode(true);
 962   DALI_TEST_CHECK(manager.GetGroupMode() == true);
 963
 964   // Check that the focus movement is now limited to the current focus group.
 965   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 966   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == secondGrandChild);
 967   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 968   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == thirdGrandChild);
 969   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 970   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstChild);
 971   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
 972   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == firstGrandChild);
 973   END_TEST;
 974 }
 975
 976 int UtcDaliAccessibilityManagerSetAndGetFocusIndicator(void)
 977 {
 978   ToolkitTestApplication application;
 979
 980   tet_infoline(" UtcDaliAccessibilityManagerSetAndGetFocusIndicator");
 981
 982   AccessibilityManager manager = AccessibilityManager::Get();
 983   DALI_TEST_CHECK(manager);
 984
 985   Actor defaultFocusIndicatorActor = manager.GetFocusIndicatorActor();
 986   DALI_TEST_CHECK(defaultFocusIndicatorActor);
 987
 988   Actor newFocusIndicatorActor = Actor::New();
 989   manager.SetFocusIndicatorActor(newFocusIndicatorActor);
 990   DALI_TEST_CHECK(manager.GetFocusIndicatorActor() == newFocusIndicatorActor);
 991   END_TEST;
 992 }
 993
 994 int UtcDaliAccessibilityManagerSignalFocusChanged(void)
 995 {
 996   ToolkitTestApplication application;
 997
 998   tet_infoline(" UtcDaliAccessibilityManagerSignalFocusChanged");
 999
1000   AccessibilityManager manager = AccessibilityManager::Get();
1001   DALI_TEST_CHECK(manager);
1002
1003   bool signalVerified = false;
1004   FocusChangedCallback callback(signalVerified);
1005   manager.FocusChangedSignal().Connect( &callback, &FocusChangedCallback::Callback );
1006
1007   // Create the first actor and add it to the stage
1008   Actor first = Actor::New();
1009   manager.SetFocusOrder(first, 1);
1010   Stage::GetCurrent().Add(first);
1011
1012   // Create the second actor and add it to the stage
1013   Actor second = Actor::New();
1014   manager.SetFocusOrder(second, 2);
1015   Stage::GetCurrent().Add(second);
1016
1017   // Check that no actor is being focused yet.
1018   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
1019
1020   // Check that the focus is set on the first actor
1021   DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
1022   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
1023   DALI_TEST_CHECK(callback.mSignalVerified);
1024   callback.Reset();
1025
1026   // Check that the focus is set on the second actor
1027   DALI_TEST_CHECK(manager.SetCurrentFocusActor(second) == true);
1028   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
1029   DALI_TEST_CHECK(callback.mSignalVerified);
1030   callback.Reset();
1031
1032   // Clear the focus
1033   manager.ClearFocus();
1034
1035   // Check that no actor is being focused now.
1036   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == Actor());
1037   DALI_TEST_CHECK(callback.mSignalVerified);
1038   END_TEST;
1039 }
1040
1041 int UtcDaliAccessibilityManagerSignalFocusOvershot(void)
1042 {
1043   ToolkitTestApplication application;
1044
1045   tet_infoline(" UtcDaliAccessibilityManagerSignalFocusOvershot");
1046
1047   AccessibilityManager manager = AccessibilityManager::Get();
1048   DALI_TEST_CHECK(manager);
1049
1050   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1051   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1052   accAdaptor.HandleActionEnableEvent();
1053
1054   bool signalVerified = false;
1055   FocusOvershotCallback callback(signalVerified);
1056   manager.FocusOvershotSignal().Connect(&callback, &FocusOvershotCallback::Callback);
1057
1058   // Create the first actor and add it to the stage
1059   Actor first = Actor::New();
1060   manager.SetFocusOrder(first, 1);
1061   Stage::GetCurrent().Add(first);
1062
1063   // Create the second actor and add it to the stage
1064   Actor second = Actor::New();
1065   manager.SetFocusOrder(second, 2);
1066   Stage::GetCurrent().Add(second);
1067
1068   // Check that the wrap mode is disabled
1069   DALI_TEST_CHECK(manager.GetWrapMode() == false);
1070
1071   // Check that the focus is set on the first actor
1072   DALI_TEST_CHECK(manager.SetCurrentFocusActor(first) == true);
1073   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
1074
1075   // Check that the focus is moved to the second actor successfully.
1076   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
1077   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
1078
1079   // Check that the forward focus movement is overshot.
1080   callback.mCurrentFocusedActor = second;
1081   callback.mFocusOvershotDirection = Toolkit::AccessibilityManager::OVERSHOT_NEXT;
1082   DALI_TEST_CHECK(manager.MoveFocusForward() == false);
1083   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == second);
1084   DALI_TEST_CHECK(signalVerified);
1085   callback.Reset();
1086
1087   // Enable the wrap mode
1088   manager.SetWrapMode(true);
1089   DALI_TEST_CHECK(manager.GetWrapMode() == true);
1090
1091   // Check that the forward focus movement is wrapped and no overshot happens.
1092   DALI_TEST_CHECK(manager.MoveFocusForward() == true);
1093   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
1094   DALI_TEST_CHECK(signalVerified == false);
1095
1096   // Disable the wrap mode
1097   manager.SetWrapMode(false);
1098   DALI_TEST_CHECK(manager.GetWrapMode() == false);
1099
1100   // Check that the backward focus movement is overshot.
1101   callback.mCurrentFocusedActor = first;
1102   callback.mFocusOvershotDirection = Toolkit::AccessibilityManager::OVERSHOT_PREVIOUS;
1103   DALI_TEST_CHECK(manager.MoveFocusBackward() == false);
1104   DALI_TEST_CHECK(manager.GetCurrentFocusActor() == first);
1105   DALI_TEST_CHECK(signalVerified);
1106   END_TEST;
1107 }
1108
1109 int UtcDaliAccessibilityManagerSignalFocusedActorActivated(void)
1110 {
1111   ToolkitTestApplication application;
1112
1113   tet_infoline(" UtcDaliAccessibilityManagerSignalFocusedActorActivated");
1114
1115   AccessibilityManager manager = AccessibilityManager::Get();
1116   DALI_TEST_CHECK(manager);
1117
1118   FocusedActorActivatedCallback callback;
1119   manager.FocusedActorActivatedSignal().Connect(&callback, &FocusedActorActivatedCallback::Callback);
1120   DALI_TEST_CHECK(true);
1121
1122   END_TEST;
1123 }
1124
1125 // Note: No negative test for GetReadPosition as it will always return something.
1126 int UtcDaliAccessibilityManagerGetReadPositionP(void)
1127 {
1128   ToolkitTestApplication application;
1129   tet_infoline(" UtcDaliAccessibilityManagerGetReadPositionP");
1130
1131   AccessibilityManager manager = AccessibilityManager::Get();
1132   DALI_TEST_CHECK( manager );
1133
1134   Vector2 readPosition( manager.GetReadPosition() );
1135   DALI_TEST_EQUALS( readPosition.x, 0.0f, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1136   DALI_TEST_EQUALS( readPosition.y, 0.0f, Math::MACHINE_EPSILON_0, TEST_LOCATION );
1137
1138   END_TEST;
1139 }
1140
1141 // Functor to test if an accessibility signal has been called.
1142 class AccessibilityManagerSignalHandler : public Dali::ConnectionTracker
1143 {
1144 public:
1145   AccessibilityManagerSignalHandler() :
1146     mCalls( 0 )
1147   {
1148   }
1149
1150   bool Callback( AccessibilityManager& accessibilityManager )
1151   {
1152     mCalls++;
1153     tet_infoline( "Signal called" );
1154     return true;
1155   }
1156
1157   unsigned int GetCalls() const
1158   {
1159     return mCalls;
1160   }
1161
1162 private:
1163   unsigned int mCalls;  ///< Keeps track of how many times the signal has been called.
1164 };
1165
1166 int UtcDaliAccessibilityManagerStatusChangedSignalP(void)
1167 {
1168   ToolkitTestApplication application;
1169   tet_infoline( " UtcDaliAccessibilityManagerStatusChangedSignalP" );
1170
1171   AccessibilityManagerSignalHandler callback;
1172
1173   AccessibilityManager manager = AccessibilityManager::Get();
1174   DALI_TEST_CHECK( manager );
1175
1176   manager.StatusChangedSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1177
1178   // Cause a state change.
1179   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1180   accessibilityAdaptor.HandleActionEnableEvent();
1181
1182   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1183
1184   END_TEST;
1185 }
1186
1187 int UtcDaliAccessibilityManagerStatusChangedSignalN(void)
1188 {
1189   ToolkitTestApplication application;
1190   tet_infoline( " UtcDaliAccessibilityManagerStatusChangedSignalN" );
1191
1192   AccessibilityManagerSignalHandler callback;
1193
1194   AccessibilityManager manager = AccessibilityManager::Get();
1195   DALI_TEST_CHECK( manager );
1196
1197   manager.StatusChangedSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1198   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1199
1200   END_TEST;
1201 }
1202
1203 int UtcDaliAccessibilityManagerActionNextSignalP(void)
1204 {
1205   ToolkitTestApplication application;
1206   tet_infoline( " UtcDaliAccessibilityManagerActionNextSignalP" );
1207
1208   AccessibilityManagerSignalHandler callback;
1209
1210   AccessibilityManager manager = AccessibilityManager::Get();
1211   DALI_TEST_CHECK( manager );
1212
1213   manager.ActionNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1214
1215   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1216   accessibilityAdaptor.HandleActionNextEvent();
1217
1218   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1219
1220   END_TEST;
1221 }
1222
1223 int UtcDaliAccessibilityManagerActionNextSignalN(void)
1224 {
1225   ToolkitTestApplication application;
1226   tet_infoline( " UtcDaliAccessibilityManagerActionNextSignalN" );
1227
1228   AccessibilityManagerSignalHandler callback;
1229
1230   AccessibilityManager manager = AccessibilityManager::Get();
1231   DALI_TEST_CHECK( manager );
1232
1233   manager.ActionNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1234   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1235
1236   END_TEST;
1237 }
1238
1239 int UtcDaliAccessibilityManagerActionPreviousSignalP(void)
1240 {
1241   ToolkitTestApplication application;
1242   tet_infoline( " UtcDaliAccessibilityManagerActionPreviousSignalP" );
1243
1244   AccessibilityManagerSignalHandler callback;
1245
1246   AccessibilityManager manager = AccessibilityManager::Get();
1247   DALI_TEST_CHECK( manager );
1248
1249   manager.ActionPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1250
1251   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1252   accessibilityAdaptor.HandleActionPreviousEvent();
1253
1254   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1255
1256   END_TEST;
1257 }
1258
1259 int UtcDaliAccessibilityManagerActionPreviousSignalN(void)
1260 {
1261   ToolkitTestApplication application;
1262   tet_infoline( " UtcDaliAccessibilityManagerActionPreviousSignalN" );
1263
1264   AccessibilityManagerSignalHandler callback;
1265
1266   AccessibilityManager manager = AccessibilityManager::Get();
1267   DALI_TEST_CHECK( manager );
1268
1269   manager.ActionPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1270   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1271
1272   END_TEST;
1273 }
1274
1275 int UtcDaliAccessibilityManagerActionActivateSignalP(void)
1276 {
1277   ToolkitTestApplication application;
1278   tet_infoline( " UtcDaliAccessibilityManagerActionActivateSignalP" );
1279
1280   AccessibilityManagerSignalHandler callback;
1281
1282   AccessibilityManager manager = AccessibilityManager::Get();
1283   DALI_TEST_CHECK( manager );
1284
1285   manager.ActionActivateSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1286
1287   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1288   accessibilityAdaptor.HandleActionActivateEvent();
1289
1290   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1291
1292   END_TEST;
1293 }
1294
1295 int UtcDaliAccessibilityManagerActionActivateSignalN(void)
1296 {
1297   ToolkitTestApplication application;
1298   tet_infoline( " UtcDaliAccessibilityManagerActionActivateSignalN" );
1299
1300   AccessibilityManagerSignalHandler callback;
1301
1302   AccessibilityManager manager = AccessibilityManager::Get();
1303   DALI_TEST_CHECK( manager );
1304
1305   manager.ActionActivateSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1306   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1307
1308   END_TEST;
1309 }
1310
1311 int UtcDaliAccessibilityManagerActionReadSignalP(void)
1312 {
1313   ToolkitTestApplication application;
1314   tet_infoline( " UtcDaliAccessibilityManagerActionReadSignalP" );
1315
1316   AccessibilityManagerSignalHandler callback;
1317
1318   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1319   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1320   accAdaptor.HandleActionEnableEvent();
1321
1322   AccessibilityManager manager = AccessibilityManager::Get();
1323   DALI_TEST_CHECK( manager );
1324
1325   manager.ActionReadSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1326
1327   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1328   accessibilityAdaptor.HandleActionReadEvent( 100.0f, 200.0f, true );
1329
1330   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1331
1332   END_TEST;
1333 }
1334
1335 int UtcDaliAccessibilityManagerActionReadSignalN(void)
1336 {
1337   ToolkitTestApplication application;
1338   tet_infoline( " UtcDaliAccessibilityManagerActionReadSignalN" );
1339
1340   AccessibilityManagerSignalHandler callback;
1341
1342   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1343   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1344   accAdaptor.HandleActionEnableEvent();
1345
1346   AccessibilityManager manager = AccessibilityManager::Get();
1347   DALI_TEST_CHECK( manager );
1348
1349   manager.ActionReadSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1350   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1351
1352   END_TEST;
1353 }
1354
1355 int UtcDaliAccessibilityManagerActionOverSignalP(void)
1356 {
1357   ToolkitTestApplication application;
1358   tet_infoline( " UtcDaliAccessibilityManagerActionOverSignalP" );
1359
1360   AccessibilityManagerSignalHandler callback;
1361
1362   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1363   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1364   accAdaptor.HandleActionEnableEvent();
1365
1366   AccessibilityManager manager = AccessibilityManager::Get();
1367   DALI_TEST_CHECK( manager );
1368
1369   manager.ActionOverSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1370
1371   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1372   // Note that the ActionOverSignal is provoked by a read even when "allow read again" is set to false.
1373   accessibilityAdaptor.HandleActionReadEvent( 100.0f, 200.0f, false );
1374
1375   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1376
1377   END_TEST;
1378 }
1379
1380 int UtcDaliAccessibilityManagerActionOverSignalN(void)
1381 {
1382   ToolkitTestApplication application;
1383   tet_infoline( " UtcDaliAccessibilityManagerActionOverSignalN" );
1384
1385   AccessibilityManagerSignalHandler callback;
1386
1387   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1388   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1389   accAdaptor.HandleActionEnableEvent();
1390
1391   AccessibilityManager manager = AccessibilityManager::Get();
1392   DALI_TEST_CHECK( manager );
1393
1394   manager.ActionOverSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1395   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1396
1397   END_TEST;
1398 }
1399
1400 int UtcDaliAccessibilityManagerActionReadNextSignalP(void)
1401 {
1402   ToolkitTestApplication application;
1403   tet_infoline( " UtcDaliAccessibilityManagerActionReadNextSignalP" );
1404
1405   AccessibilityManagerSignalHandler callback;
1406
1407   AccessibilityManager manager = AccessibilityManager::Get();
1408   DALI_TEST_CHECK( manager );
1409
1410   manager.ActionReadNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1411
1412   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1413   accessibilityAdaptor.HandleActionReadNextEvent();
1414
1415   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1416
1417   END_TEST;
1418 }
1419
1420 int UtcDaliAccessibilityManagerActionReadNextSignalN(void)
1421 {
1422   ToolkitTestApplication application;
1423   tet_infoline( " UtcDaliAccessibilityManagerActionReadNextSignalN" );
1424
1425   AccessibilityManagerSignalHandler callback;
1426
1427   AccessibilityManager manager = AccessibilityManager::Get();
1428   DALI_TEST_CHECK( manager );
1429
1430   manager.ActionReadNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1431   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1432
1433   END_TEST;
1434 }
1435
1436 int UtcDaliAccessibilityManagerActionReadPreviousSignalP(void)
1437 {
1438   ToolkitTestApplication application;
1439   tet_infoline( " UtcDaliAccessibilityManagerActionReadPreviousSignalP" );
1440
1441   AccessibilityManagerSignalHandler callback;
1442
1443   AccessibilityManager manager = AccessibilityManager::Get();
1444   DALI_TEST_CHECK( manager );
1445
1446   manager.ActionReadPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1447
1448   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1449   accessibilityAdaptor.HandleActionReadPreviousEvent();
1450
1451   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1452
1453   END_TEST;
1454 }
1455
1456 int UtcDaliAccessibilityManagerActionReadPreviousSignalN(void)
1457 {
1458   ToolkitTestApplication application;
1459   tet_infoline( " UtcDaliAccessibilityManagerActionReadPreviousSignalN" );
1460
1461   AccessibilityManagerSignalHandler callback;
1462
1463   AccessibilityManager manager = AccessibilityManager::Get();
1464   DALI_TEST_CHECK( manager );
1465
1466   manager.ActionReadPreviousSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1467   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1468
1469   END_TEST;
1470 }
1471
1472 int UtcDaliAccessibilityManagerActionUpSignalP(void)
1473 {
1474   ToolkitTestApplication application;
1475   tet_infoline( " UtcDaliAccessibilityManagerActionUpSignalP" );
1476
1477   AccessibilityManagerSignalHandler callback;
1478
1479   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1480   Test::AccessibilityAdaptor::SetEnabled( accessibilityAdaptor, true );
1481   accessibilityAdaptor.HandleActionEnableEvent();
1482
1483   AccessibilityManager manager = AccessibilityManager::Get();
1484   DALI_TEST_CHECK( manager );
1485
1486   manager.ActionUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1487
1488   DummyControl dummyControl = DummyControl::New(true);
1489   dummyControl.SetSize(480, 800);
1490   manager.SetFocusOrder( dummyControl, 1 );
1491   Stage::GetCurrent().Add( dummyControl );
1492   manager.SetCurrentFocusActor( dummyControl );
1493
1494   accessibilityAdaptor.HandleActionUpEvent();
1495
1496   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1497
1498   END_TEST;
1499 }
1500
1501 int UtcDaliAccessibilityManagerActionUpSignalN(void)
1502 {
1503   ToolkitTestApplication application;
1504   tet_infoline( " UtcDaliAccessibilityManagerActionUpSignalN" );
1505
1506   AccessibilityManagerSignalHandler callback;
1507
1508   AccessibilityManager manager = AccessibilityManager::Get();
1509   DALI_TEST_CHECK( manager );
1510
1511   manager.ActionUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1512   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1513
1514   END_TEST;
1515 }
1516
1517 int UtcDaliAccessibilityManagerActionDownSignalP(void)
1518 {
1519   ToolkitTestApplication application;
1520   tet_infoline( " UtcDaliAccessibilityManagerActionDownSignalP" );
1521
1522   AccessibilityManagerSignalHandler callback;
1523
1524   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1525   Test::AccessibilityAdaptor::SetEnabled( accessibilityAdaptor, true );
1526   accessibilityAdaptor.HandleActionEnableEvent();
1527
1528   AccessibilityManager manager = AccessibilityManager::Get();
1529   DALI_TEST_CHECK( manager );
1530
1531   manager.ActionDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1532
1533   DummyControl dummyControl = DummyControl::New(true);
1534   dummyControl.SetSize(480, 800);
1535   manager.SetFocusOrder( dummyControl, 1 );
1536   Stage::GetCurrent().Add( dummyControl );
1537   manager.SetCurrentFocusActor( dummyControl );
1538
1539   accessibilityAdaptor.HandleActionDownEvent();
1540
1541   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1542
1543   END_TEST;
1544 }
1545
1546 int UtcDaliAccessibilityManagerActionDownSignalN(void)
1547 {
1548   ToolkitTestApplication application;
1549   tet_infoline( " UtcDaliAccessibilityManagerActionDownSignalN" );
1550
1551   AccessibilityManagerSignalHandler callback;
1552
1553   AccessibilityManager manager = AccessibilityManager::Get();
1554   DALI_TEST_CHECK( manager );
1555
1556   manager.ActionDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1557   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1558
1559   END_TEST;
1560 }
1561
1562 int UtcDaliAccessibilityManagerActionClearFocusSignalP(void)
1563 {
1564   ToolkitTestApplication application;
1565   tet_infoline( " UtcDaliAccessibilityManagerActionClearFocusSignalP" );
1566
1567   AccessibilityManagerSignalHandler callback;
1568
1569   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1570   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1571   accAdaptor.HandleActionEnableEvent();
1572
1573   AccessibilityManager manager = AccessibilityManager::Get();
1574   DALI_TEST_CHECK( manager );
1575
1576   manager.ActionClearFocusSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1577
1578   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1579   accessibilityAdaptor.HandleActionClearFocusEvent();
1580
1581   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1582
1583   END_TEST;
1584 }
1585
1586 int UtcDaliAccessibilityManagerActionClearFocusSignalN(void)
1587 {
1588   ToolkitTestApplication application;
1589   tet_infoline( " UtcDaliAccessibilityManagerActionClearFocusSignalN" );
1590
1591   AccessibilityManagerSignalHandler callback;
1592
1593   AccessibilityManager manager = AccessibilityManager::Get();
1594   DALI_TEST_CHECK( manager );
1595
1596   manager.ActionClearFocusSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1597   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1598
1599   END_TEST;
1600 }
1601
1602 int UtcDaliAccessibilityManagerActionBackSignalP(void)
1603 {
1604   ToolkitTestApplication application;
1605   tet_infoline( " UtcDaliAccessibilityManagerActionBackSignalP" );
1606
1607   AccessibilityManagerSignalHandler callback;
1608
1609   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1610   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1611   accAdaptor.HandleActionEnableEvent();
1612
1613   AccessibilityManager manager = AccessibilityManager::Get();
1614   DALI_TEST_CHECK( manager );
1615
1616   manager.ActionBackSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1617
1618   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1619   accessibilityAdaptor.HandleActionBackEvent();
1620
1621   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1622
1623   END_TEST;
1624 }
1625
1626 int UtcDaliAccessibilityManagerActionBackSignalN(void)
1627 {
1628   ToolkitTestApplication application;
1629   tet_infoline( " UtcDaliAccessibilityManagerActionBackSignalN" );
1630
1631   AccessibilityManagerSignalHandler callback;
1632
1633   AccessibilityManager manager = AccessibilityManager::Get();
1634   DALI_TEST_CHECK( manager );
1635
1636   manager.ActionBackSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1637   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1638
1639   END_TEST;
1640 }
1641
1642 int UtcDaliAccessibilityManagerActionScrollUpSignalP(void)
1643 {
1644   ToolkitTestApplication application;
1645   tet_infoline( " UtcDaliAccessibilityManagerActionScrollUpSignalP" );
1646
1647   AccessibilityManagerSignalHandler callback;
1648
1649   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1650   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1651   accAdaptor.HandleActionEnableEvent();
1652
1653   AccessibilityManager manager = AccessibilityManager::Get();
1654   DALI_TEST_CHECK( manager );
1655
1656   manager.ActionScrollUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1657
1658   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1659   accessibilityAdaptor.HandleActionScrollUpEvent();
1660
1661   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1662
1663   END_TEST;
1664 }
1665
1666 int UtcDaliAccessibilityManagerActionScrollUpSignalN(void)
1667 {
1668   ToolkitTestApplication application;
1669   tet_infoline( " UtcDaliAccessibilityManagerActionScrollUpSignalN" );
1670
1671   AccessibilityManagerSignalHandler callback;
1672
1673   AccessibilityManager manager = AccessibilityManager::Get();
1674   DALI_TEST_CHECK( manager );
1675
1676   manager.ActionScrollUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1677   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1678
1679   END_TEST;
1680 }
1681
1682 int UtcDaliAccessibilityManagerActionScrollDownSignalP(void)
1683 {
1684   ToolkitTestApplication application;
1685   tet_infoline( " UtcDaliAccessibilityManagerActionScrollDownSignalP" );
1686
1687   AccessibilityManagerSignalHandler callback;
1688
1689   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1690   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1691   accAdaptor.HandleActionEnableEvent();
1692
1693   AccessibilityManager manager = AccessibilityManager::Get();
1694   DALI_TEST_CHECK( manager );
1695
1696   manager.ActionScrollDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1697
1698   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1699   accessibilityAdaptor.HandleActionScrollDownEvent();
1700
1701   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1702
1703   END_TEST;
1704 }
1705
1706 int UtcDaliAccessibilityManagerActionScrollDownSignalN(void)
1707 {
1708   ToolkitTestApplication application;
1709   tet_infoline( " UtcDaliAccessibilityManagerActionScrollDownSignalN" );
1710
1711   AccessibilityManagerSignalHandler callback;
1712
1713   AccessibilityManager manager = AccessibilityManager::Get();
1714   DALI_TEST_CHECK( manager );
1715
1716   manager.ActionScrollDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1717   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1718
1719   END_TEST;
1720 }
1721
1722 int UtcDaliAccessibilityManagerActionPageLeftSignalP(void)
1723 {
1724   ToolkitTestApplication application;
1725   tet_infoline( " UtcDaliAccessibilityManagerActionPageLeftSignalP" );
1726
1727   AccessibilityManagerSignalHandler callback;
1728
1729   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1730   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1731   accAdaptor.HandleActionEnableEvent();
1732
1733   AccessibilityManager manager = AccessibilityManager::Get();
1734   DALI_TEST_CHECK( manager );
1735
1736   manager.ActionPageLeftSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1737
1738   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1739   accessibilityAdaptor.HandleActionPageLeftEvent();
1740
1741   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1742
1743   END_TEST;
1744 }
1745
1746 int UtcDaliAccessibilityManagerActionPageLeftSignalN(void)
1747 {
1748   ToolkitTestApplication application;
1749   tet_infoline( " UtcDaliAccessibilityManagerActionPageLeftSignalN" );
1750
1751   AccessibilityManagerSignalHandler callback;
1752
1753   AccessibilityManager manager = AccessibilityManager::Get();
1754   DALI_TEST_CHECK( manager );
1755
1756   manager.ActionPageLeftSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1757   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1758
1759   END_TEST;
1760 }
1761
1762 int UtcDaliAccessibilityManagerActionPageRightSignalP(void)
1763 {
1764   ToolkitTestApplication application;
1765   tet_infoline( " UtcDaliAccessibilityManagerActionPageRightSignalP" );
1766
1767   AccessibilityManagerSignalHandler callback;
1768
1769   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1770   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1771   accAdaptor.HandleActionEnableEvent();
1772
1773   AccessibilityManager manager = AccessibilityManager::Get();
1774   DALI_TEST_CHECK( manager );
1775
1776   manager.ActionPageRightSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1777
1778   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1779   accessibilityAdaptor.HandleActionPageRightEvent();
1780
1781   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1782
1783   END_TEST;
1784 }
1785
1786 int UtcDaliAccessibilityManagerActionPageRightSignalN(void)
1787 {
1788   ToolkitTestApplication application;
1789   tet_infoline( " UtcDaliAccessibilityManagerActionPageRightSignalN" );
1790
1791   AccessibilityManagerSignalHandler callback;
1792
1793   AccessibilityManager manager = AccessibilityManager::Get();
1794   DALI_TEST_CHECK( manager );
1795
1796   manager.ActionPageRightSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1797   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1798
1799   END_TEST;
1800 }
1801
1802 int UtcDaliAccessibilityManagerActionPageUpSignalP(void)
1803 {
1804   ToolkitTestApplication application;
1805   tet_infoline( " UtcDaliAccessibilityManagerActionPageUpSignalP" );
1806
1807   AccessibilityManagerSignalHandler callback;
1808
1809   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1810   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1811   accAdaptor.HandleActionEnableEvent();
1812
1813   AccessibilityManager manager = AccessibilityManager::Get();
1814   DALI_TEST_CHECK( manager );
1815
1816   manager.ActionPageUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1817
1818   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1819   accessibilityAdaptor.HandleActionPageUpEvent();
1820
1821   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1822
1823   END_TEST;
1824 }
1825
1826 int UtcDaliAccessibilityManagerActionPageUpSignalN(void)
1827 {
1828   ToolkitTestApplication application;
1829   tet_infoline( " UtcDaliAccessibilityManagerActionPageUpSignalN" );
1830
1831   AccessibilityManagerSignalHandler callback;
1832
1833   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1834   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1835   accAdaptor.HandleActionEnableEvent();
1836
1837   AccessibilityManager manager = AccessibilityManager::Get();
1838   DALI_TEST_CHECK( manager );
1839
1840   manager.ActionPageUpSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1841   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1842
1843   END_TEST;
1844 }
1845
1846 int UtcDaliAccessibilityManagerActionPageDownSignalP(void)
1847 {
1848   ToolkitTestApplication application;
1849   tet_infoline( " UtcDaliAccessibilityManagerActionPageDownSignalP" );
1850
1851   AccessibilityManagerSignalHandler callback;
1852
1853   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1854   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1855   accAdaptor.HandleActionEnableEvent();
1856
1857   AccessibilityManager manager = AccessibilityManager::Get();
1858   DALI_TEST_CHECK( manager );
1859
1860   manager.ActionPageDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1861
1862   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1863   accessibilityAdaptor.HandleActionPageDownEvent();
1864
1865   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1866
1867   END_TEST;
1868 }
1869
1870 int UtcDaliAccessibilityManagerActionPageDownSignalN(void)
1871 {
1872   ToolkitTestApplication application;
1873   tet_infoline( " UtcDaliAccessibilityManagerActionPageDownSignalN" );
1874
1875   AccessibilityManagerSignalHandler callback;
1876
1877   AccessibilityManager manager = AccessibilityManager::Get();
1878   DALI_TEST_CHECK( manager );
1879
1880   manager.ActionPageDownSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1881   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1882
1883   END_TEST;
1884 }
1885
1886 int UtcDaliAccessibilityManagerActionMoveToFirstSignalP(void)
1887 {
1888   ToolkitTestApplication application;
1889   tet_infoline( " UtcDaliAccessibilityManagerActionMoveToFirstSignalP" );
1890
1891   AccessibilityManagerSignalHandler callback;
1892
1893   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1894   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1895   accAdaptor.HandleActionEnableEvent();
1896
1897   AccessibilityManager manager = AccessibilityManager::Get();
1898   DALI_TEST_CHECK( manager );
1899
1900   manager.ActionMoveToFirstSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1901
1902   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1903   accessibilityAdaptor.HandleActionMoveToFirstEvent();
1904
1905   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1906
1907   END_TEST;
1908 }
1909
1910 int UtcDaliAccessibilityManagerActionMoveToFirstSignalN(void)
1911 {
1912   ToolkitTestApplication application;
1913   tet_infoline( " UtcDaliAccessibilityManagerActionMoveToFirstSignalN" );
1914
1915   AccessibilityManagerSignalHandler callback;
1916
1917   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1918   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1919   accAdaptor.HandleActionEnableEvent();
1920
1921   AccessibilityManager manager = AccessibilityManager::Get();
1922   DALI_TEST_CHECK( manager );
1923
1924   manager.ActionMoveToFirstSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1925   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1926
1927   END_TEST;
1928 }
1929
1930 int UtcDaliAccessibilityManagerActionMoveToLastSignalP(void)
1931 {
1932   ToolkitTestApplication application;
1933   tet_infoline( " UtcDaliAccessibilityManagerActionMoveToLastSignalP" );
1934
1935   AccessibilityManagerSignalHandler callback;
1936
1937   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1938   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1939   accAdaptor.HandleActionEnableEvent();
1940
1941   AccessibilityManager manager = AccessibilityManager::Get();
1942   DALI_TEST_CHECK( manager );
1943
1944   manager.ActionMoveToLastSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1945
1946   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1947   accessibilityAdaptor.HandleActionMoveToLastEvent();
1948
1949   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1950
1951   END_TEST;
1952 }
1953
1954 int UtcDaliAccessibilityManagerActionMoveToLastSignalN(void)
1955 {
1956   ToolkitTestApplication application;
1957   tet_infoline( " UtcDaliAccessibilityManagerActionMoveToLastSignalN" );
1958
1959   AccessibilityManagerSignalHandler callback;
1960
1961   AccessibilityManager manager = AccessibilityManager::Get();
1962   DALI_TEST_CHECK( manager );
1963
1964   manager.ActionMoveToLastSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1965   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
1966
1967   END_TEST;
1968 }
1969
1970 int UtcDaliAccessibilityManagerActionReadFromTopSignalP(void)
1971 {
1972   ToolkitTestApplication application;
1973   tet_infoline( " UtcDaliAccessibilityManagerActionReadFromTopSignalP" );
1974
1975   AccessibilityManagerSignalHandler callback;
1976
1977   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
1978   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
1979   accAdaptor.HandleActionEnableEvent();
1980
1981   AccessibilityManager manager = AccessibilityManager::Get();
1982   DALI_TEST_CHECK( manager );
1983
1984   manager.ActionReadFromTopSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
1985
1986   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
1987   accessibilityAdaptor.HandleActionReadFromTopEvent();
1988
1989   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
1990
1991   END_TEST;
1992 }
1993
1994 int UtcDaliAccessibilityManagerActionReadFromTopSignalN(void)
1995 {
1996   ToolkitTestApplication application;
1997   tet_infoline( " UtcDaliAccessibilityManagerActionReadFromTopSignalN" );
1998
1999   AccessibilityManagerSignalHandler callback;
2000
2001   AccessibilityManager manager = AccessibilityManager::Get();
2002   DALI_TEST_CHECK( manager );
2003
2004   manager.ActionReadFromTopSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2005   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
2006
2007   END_TEST;
2008 }
2009
2010 int UtcDaliAccessibilityManagerActionReadFromNextSignalP(void)
2011 {
2012   ToolkitTestApplication application;
2013   tet_infoline( " UtcDaliAccessibilityManagerActionReadFromNextSignalP" );
2014
2015   AccessibilityManagerSignalHandler callback;
2016
2017   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
2018   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
2019   accAdaptor.HandleActionEnableEvent();
2020
2021   AccessibilityManager manager = AccessibilityManager::Get();
2022   DALI_TEST_CHECK( manager );
2023
2024   manager.ActionReadFromNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2025
2026   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
2027   accessibilityAdaptor.HandleActionReadFromNextEvent();
2028
2029   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
2030
2031   END_TEST;
2032 }
2033
2034 int UtcDaliAccessibilityManagerActionReadFromNextSignalN(void)
2035 {
2036   ToolkitTestApplication application;
2037   tet_infoline( " UtcDaliAccessibilityManagerActionReadFromNextSignalN" );
2038
2039   AccessibilityManagerSignalHandler callback;
2040
2041   AccessibilityManager manager = AccessibilityManager::Get();
2042   DALI_TEST_CHECK( manager );
2043
2044   manager.ActionReadFromNextSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2045   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
2046
2047   END_TEST;
2048 }
2049
2050 int UtcDaliAccessibilityManagerActionZoomSignalP(void)
2051 {
2052   ToolkitTestApplication application;
2053   tet_infoline( " UtcDaliAccessibilityManagerActionZoomSignalP" );
2054
2055   AccessibilityManagerSignalHandler callback;
2056
2057   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
2058   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
2059   accAdaptor.HandleActionEnableEvent();
2060
2061   AccessibilityManager manager = AccessibilityManager::Get();
2062   DALI_TEST_CHECK( manager );
2063
2064   manager.ActionZoomSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2065
2066   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
2067   accessibilityAdaptor.HandleActionZoomEvent();
2068
2069   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
2070
2071   END_TEST;
2072 }
2073
2074 int UtcDaliAccessibilityManagerActionZoomSignalN(void)
2075 {
2076   ToolkitTestApplication application;
2077   tet_infoline( " UtcDaliAccessibilityManagerActionZoomSignalN" );
2078
2079   AccessibilityManagerSignalHandler callback;
2080
2081   AccessibilityManager manager = AccessibilityManager::Get();
2082   DALI_TEST_CHECK( manager );
2083
2084   manager.ActionZoomSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2085   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
2086
2087   END_TEST;
2088 }
2089
2090 int UtcDaliAccessibilityManagerActionReadIndicatorInformationSignalP(void)
2091 {
2092   ToolkitTestApplication application;
2093   tet_infoline( " UtcDaliAccessibilityManagerActionReadIndicatorInformationSignalP" );
2094
2095   AccessibilityManagerSignalHandler callback;
2096
2097   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
2098   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
2099   accAdaptor.HandleActionEnableEvent();
2100
2101   AccessibilityManager manager = AccessibilityManager::Get();
2102   DALI_TEST_CHECK( manager );
2103
2104   manager.ActionReadIndicatorInformationSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2105
2106   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
2107   accessibilityAdaptor.HandleActionReadIndicatorInformationEvent();
2108
2109   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
2110
2111   END_TEST;
2112 }
2113
2114 int UtcDaliAccessibilityManagerActionReadIndicatorInformationSignalN(void)
2115 {
2116   ToolkitTestApplication application;
2117   tet_infoline( " UtcDaliAccessibilityManagerActionReadIndicatorInformationSignalN" );
2118
2119   AccessibilityManagerSignalHandler callback;
2120
2121   AccessibilityManager manager = AccessibilityManager::Get();
2122   DALI_TEST_CHECK( manager );
2123
2124   manager.ActionReadIndicatorInformationSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2125   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
2126
2127   END_TEST;
2128 }
2129
2130 int UtcDaliAccessibilityManagerActionReadPauseResumeSignalP(void)
2131 {
2132   ToolkitTestApplication application;
2133   tet_infoline( " UtcDaliAccessibilityManagerActionReadPauseResumeSignalP" );
2134
2135   AccessibilityManagerSignalHandler callback;
2136
2137   Dali::AccessibilityAdaptor accAdaptor = Dali::AccessibilityAdaptor::Get();
2138   Test::AccessibilityAdaptor::SetEnabled( accAdaptor, true );
2139   accAdaptor.HandleActionEnableEvent();
2140
2141   AccessibilityManager manager = AccessibilityManager::Get();
2142   DALI_TEST_CHECK( manager );
2143
2144   manager.ActionReadPauseResumeSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2145
2146   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
2147   accessibilityAdaptor.HandleActionReadPauseResumeEvent();
2148
2149   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
2150
2151   END_TEST;
2152 }
2153
2154 int UtcDaliAccessibilityManagerActionReadPauseResumeSignalN(void)
2155 {
2156   ToolkitTestApplication application;
2157   tet_infoline( " UtcDaliAccessibilityManagerActionReadPauseResumeSignalN" );
2158
2159   AccessibilityManagerSignalHandler callback;
2160
2161   AccessibilityManager manager = AccessibilityManager::Get();
2162   DALI_TEST_CHECK( manager );
2163
2164   manager.ActionReadPauseResumeSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2165   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
2166
2167   END_TEST;
2168 }
2169
2170 int UtcDaliAccessibilityManagerActionStartStopSignalP(void)
2171 {
2172   ToolkitTestApplication application;
2173   tet_infoline( " UtcDaliAccessibilityManagerActionStartStopSignalP" );
2174
2175   AccessibilityManagerSignalHandler callback;
2176
2177   AccessibilityManager manager = AccessibilityManager::Get();
2178   DALI_TEST_CHECK( manager );
2179
2180   manager.ActionStartStopSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2181
2182   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
2183   accessibilityAdaptor.HandleActionStartStopEvent();
2184
2185   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
2186
2187   END_TEST;
2188 }
2189
2190 int UtcDaliAccessibilityManagerActionStartStopSignalN(void)
2191 {
2192   ToolkitTestApplication application;
2193   tet_infoline( " UtcDaliAccessibilityManagerActionStartStopSignalN" );
2194
2195   AccessibilityManagerSignalHandler callback;
2196
2197   AccessibilityManager manager = AccessibilityManager::Get();
2198   DALI_TEST_CHECK( manager );
2199
2200   manager.ActionStartStopSignal().Connect( &callback, &AccessibilityManagerSignalHandler::Callback );
2201   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
2202
2203   END_TEST;
2204 }
2205
2206 // Functor to test if a accessibility scroll signal has been called.
2207 class AccessibilityManagerScrollSignalHandler : public Dali::ConnectionTracker
2208 {
2209 public:
2210   AccessibilityManagerScrollSignalHandler() :
2211     mCalls( 0 )
2212   {
2213   }
2214
2215   bool Callback( AccessibilityManager& accessibilityManager, const Dali::TouchEvent& touchEvent )
2216   {
2217     mCalls++;
2218     mTouchEvent = touchEvent;
2219     tet_infoline( "Signal called" );
2220     return true;
2221   }
2222
2223   unsigned int GetCalls() const
2224   {
2225     return mCalls;
2226   }
2227
2228   const Dali::TouchEvent& GetTouchEvent() const
2229   {
2230     return mTouchEvent;
2231   }
2232
2233 private:
2234   unsigned int mCalls;         ///< Keeps track of how many times the signal has been called.
2235   Dali::TouchEvent mTouchEvent; ///< Stores the last touch event received.
2236 };
2237
2238 int UtcDaliAccessibilityManagerActionScrollSignalP(void)
2239 {
2240   ToolkitTestApplication application;
2241   tet_infoline( " UtcDaliAccessibilityManagerActionScrollSignalP" );
2242
2243   AccessibilityManagerScrollSignalHandler callback;
2244
2245   AccessibilityManager manager = AccessibilityManager::Get();
2246   DALI_TEST_CHECK( manager );
2247
2248   manager.ActionScrollSignal().Connect( &callback, &AccessibilityManagerScrollSignalHandler::Callback );
2249
2250   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
2251
2252   TouchPoint point( 0, TouchPoint::Started, 100.0f, 200.0f );
2253   accessibilityAdaptor.HandleActionScrollEvent( point, 0u );
2254
2255   DALI_TEST_EQUALS( callback.GetCalls(), 1u, TEST_LOCATION );
2256
2257   const TouchEvent& signalTouchEvent = callback.GetTouchEvent();
2258   DALI_TEST_EQUALS( signalTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
2259
2260   const TouchPoint& signalTouchPoint = signalTouchEvent.GetPoint( 0u );
2261
2262   DALI_TEST_EQUALS( signalTouchPoint.state, TouchPoint::Started, TEST_LOCATION );
2263   DALI_TEST_EQUALS( signalTouchPoint.screen.x, 100.0f, TEST_LOCATION );
2264   DALI_TEST_EQUALS( signalTouchPoint.screen.y, 200.0f, TEST_LOCATION );
2265
2266   END_TEST;
2267 }
2268
2269 int UtcDaliAccessibilityManagerActionScrollSignalN(void)
2270 {
2271   ToolkitTestApplication application;
2272   tet_infoline( " UtcDaliAccessibilityManagerActionScrollSignalN" );
2273
2274   AccessibilityManagerScrollSignalHandler callback;
2275
2276   AccessibilityManager manager = AccessibilityManager::Get();
2277   DALI_TEST_CHECK( manager );
2278
2279   manager.ActionScrollSignal().Connect( &callback, &AccessibilityManagerScrollSignalHandler::Callback );
2280
2281   DALI_TEST_EQUALS( callback.GetCalls(), 0u, TEST_LOCATION );
2282
2283   END_TEST;
2284 }
2285
2286 int UtcDaliAccessibilityManagerActionTouch(void)
2287 {
2288   ToolkitTestApplication application;
2289   tet_infoline( " UtcDaliAccessibilityManagerActionTouch" );
2290
2291   AccessibilityManager manager = AccessibilityManager::Get();
2292   DALI_TEST_CHECK( manager );
2293
2294   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
2295
2296   DummyControl dummyControl = DummyControl::New(true);
2297   DummyControlImplOverride& dummyImpl = static_cast<DummyControlImplOverride&>(dummyControl.GetImplementation());
2298   dummyControl.SetSize(480, 800);
2299   manager.SetFocusOrder( dummyControl, 1 );
2300   Stage::GetCurrent().Add( dummyControl );
2301   manager.SetCurrentFocusActor( dummyControl );
2302
2303   TouchPoint point( 0, TouchPoint::Started, 100.0f, 200.0f );
2304   accessibilityAdaptor.HandleActionTouchEvent( point, 0u );
2305
2306   DALI_TEST_CHECK( dummyImpl.onAccTouchedCalled );
2307
2308   END_TEST;
2309 }
2310
2311
2312 int UtcDaliAccessibilityManagerHandlePanGesture(void)
2313 {
2314   // Pan gesture sent from adaptor to manager via AccessibilityGestureHandler
2315   // Adaptor.SetGestureHandler is called in Initialize (check it's the toolkit version)
2316   ToolkitTestApplication application;
2317   tet_infoline( " UtcDaliAccessibilityManagerHandlePanGesture" );
2318
2319   AccessibilityManager manager = AccessibilityManager::Get();
2320   DALI_TEST_CHECK( manager );
2321
2322   Dali::AccessibilityAdaptor accessibilityAdaptor = Dali::AccessibilityAdaptor::Get();
2323   DummyControl dummyControl = DummyControl::New(true);
2324   dummyControl.SetSize(480, 800);
2325   Stage::GetCurrent().Add( dummyControl );
2326
2327   Dali::Integration::PanGestureEvent panGestureEvent(Gesture::Started);
2328   panGestureEvent.previousPosition = Vector2(0.f, 0.f);
2329   panGestureEvent.currentPosition = Vector2(100.f, 0.f);
2330   panGestureEvent.timeDelta = 16;
2331   panGestureEvent.numberOfTouches = 1;
2332
2333   Test::AccessibilityAdaptor::SendPanGesture( accessibilityAdaptor, panGestureEvent );
2334
2335   panGestureEvent.state = Gesture::Continuing;
2336   panGestureEvent.previousPosition = Vector2(100.f, 0.f);
2337   panGestureEvent.currentPosition = Vector2(200.f, 0.f);
2338   Test::AccessibilityAdaptor::SendPanGesture( accessibilityAdaptor, panGestureEvent );
2339
2340   panGestureEvent.state = Gesture::Finished;
2341   panGestureEvent.previousPosition = Vector2(200.f, 0.f);
2342   panGestureEvent.currentPosition = Vector2(300.f, 0.f);
2343   Test::AccessibilityAdaptor::SendPanGesture( accessibilityAdaptor, panGestureEvent );
2344
2345
2346   END_TEST;
2347 }
2348
2349 // Methods missing coverage:
2350 // IsActorFocusableFunction
2351 // DoActivate
2352 // SetFocusable
2353 // TtsStateChanged