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

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