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

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