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

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