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

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