automated-tests/TET/dali-test-suite/focus-manager/utc-Dali-KeyInputFocusManager.cpp

   1 /*
   2  * Copyright (c) 2014 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
  20 #include <stdlib.h>
  21 #include <tet_api.h>
  22
  23 #include <dali/dali.h>
  24 #include <dali-toolkit/dali-toolkit.h>
  25
  26 #include <dali/integration-api/events/key-event-integ.h>
  27
  28 #include <dali-toolkit-test-suite-utils.h>
  29
  30 using namespace Dali;
  31 using namespace Toolkit;
  32
  33 namespace
  34 {
  35
  36 /**
  37  * Callback class for KeyInputFocusChanged signal.
  38  */
  39 class KeyInputFocusChangedCallback : public Dali::ConnectionTracker
  40 {
  41 public:
  42   /**
  43    * Constructor
  44    * @param[in]  gainActor  Ref to the actor that should be set as the one that gains key input focus.
  45    * @param[in]  lostActor  Ref to the actor that should be set as the one that loses key input focus.
  46    */
  47   KeyInputFocusChangedCallback( Control& gainActor, Control& lostActor )
  48   : mActorGain( gainActor ),
  49     mActorLost( lostActor )
  50   {
  51   }
  52
  53   void Callback( Control gainingActor, Control lostActor )
  54   {
  55     mActorGain = gainingActor;
  56     mActorLost = lostActor;
  57   }
  58
  59   Control& mActorGain;
  60   Control& mActorLost;
  61 };
  62
  63 // Stores data that is populated in the callback and will be read by the TET cases
  64 struct SignalData
  65 {
  66   SignalData()
  67   : functorCalled(false)
  68   {}
  69
  70   void Reset()
  71   {
  72     functorCalled = false;
  73
  74     receivedKeyEvent.keyModifier = 0;
  75     receivedKeyEvent.keyPressedName.clear();
  76     receivedKeyEvent.keyPressed.clear();
  77
  78   }
  79
  80   bool functorCalled;
  81   KeyEvent receivedKeyEvent;
  82 };
  83
  84 /**
  85  * Callback class to test SignalUnhandledKeyEvent signal
  86  */
  87 class SignalUnhandledKeyEventCallback : public Dali::ConnectionTracker
  88 {
  89 public:
  90   SignalUnhandledKeyEventCallback( SignalData& data ) : mSignalData( data ) { }
  91
  92   void Callback(const KeyEvent& event)
  93   {
  94     mSignalData.functorCalled = true;
  95     mSignalData.receivedKeyEvent = event;
  96   }
  97
  98   SignalData& mSignalData;
  99 };
 100
 101 } // namespace
 102
 103 static void Startup();
 104 static void Cleanup();
 105
 106 extern "C" {
 107   void (*tet_startup)() = Startup;
 108   void (*tet_cleanup)() = Cleanup;
 109 }
 110
 111 enum {
 112   POSITIVE_TC_IDX = 0x01,
 113   NEGATIVE_TC_IDX,
 114 };
 115
 116 #define MAX_NUMBER_OF_TESTS 10000
 117 extern "C" {
 118   struct tet_testlist tet_testlist[MAX_NUMBER_OF_TESTS];
 119 }
 120
 121 // Add test functionality for all APIs in the class (Positive and Negative)
 122 TEST_FUNCTION( UtcDaliKeyInputFocusManagerGet,                        POSITIVE_TC_IDX );
 123 TEST_FUNCTION( UtcDaliKeyInputFocusManagerSetFocus,                   POSITIVE_TC_IDX );
 124 TEST_FUNCTION( UtcDaliKeyInputFocusManagerGetCurrentFocusControl,     POSITIVE_TC_IDX );
 125 TEST_FUNCTION( UtcDaliKeyInputFocusManagerRemoveFocus,                POSITIVE_TC_IDX );
 126 TEST_FUNCTION( UtcDaliKeyInputFocusManagerIsKeyboardListener,         POSITIVE_TC_IDX );
 127 TEST_FUNCTION( UtcDaliKeyInputFocusManagerSignalKeyInputFocusChanged, POSITIVE_TC_IDX );
 128 TEST_FUNCTION( UtcDaliKeyInputFocusManagerSignalUnhandledKeyEvent,    POSITIVE_TC_IDX );
 129
 130 // Called only once before first test is run.
 131 static void Startup()
 132 {
 133 }
 134
 135 // Called only once after last test is run
 136 static void Cleanup()
 137 {
 138 }
 139
 140 static void UtcDaliKeyInputFocusManagerGet()
 141 {
 142   ToolkitTestApplication application;
 143
 144   tet_infoline(" UtcDaliKeyInputFocusManagerGet");
 145
 146   KeyInputFocusManager manager;
 147   {
 148     manager = KeyInputFocusManager::Get();
 149     DALI_TEST_CHECK(manager);
 150   }
 151
 152   KeyInputFocusManager newManager = KeyInputFocusManager::Get();
 153   DALI_TEST_CHECK(newManager);
 154
 155   // Check that focus manager is a singleton
 156   DALI_TEST_CHECK(manager == newManager);
 157 }
 158
 159 static void UtcDaliKeyInputFocusManagerSetFocus()
 160 {
 161   ToolkitTestApplication application;
 162   Stage stage = Stage::GetCurrent();
 163
 164   tet_infoline(" UtcDaliKeyInputFocusManagerSetFocus");
 165
 166   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 167   DALI_TEST_CHECK(manager);
 168
 169   PushButton pushButton1 = PushButton::New();
 170   stage.Add( pushButton1 );
 171
 172   manager.SetFocus(pushButton1);
 173   DALI_TEST_CHECK(pushButton1.HasKeyInputFocus());
 174 }
 175
 176 static void UtcDaliKeyInputFocusManagerGetCurrentFocusControl()
 177 {
 178   ToolkitTestApplication application;
 179   Stage stage = Stage::GetCurrent();
 180
 181   tet_infoline(" UtcDaliKeyInputFocusManagerGetCurrentFocusControl");
 182
 183   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 184   DALI_TEST_CHECK(manager);
 185
 186   PushButton pushButton1 = PushButton::New();
 187   PushButton pushButton2 = PushButton::New();
 188   stage.Add( pushButton1 );
 189   stage.Add( pushButton2 );
 190
 191   manager.SetFocus(pushButton1);
 192   DALI_TEST_CHECK(pushButton1 == manager.GetCurrentFocusControl());
 193
 194   manager.SetFocus(pushButton2);
 195   DALI_TEST_CHECK(pushButton2 == manager.GetCurrentFocusControl());
 196
 197   manager.SetFocus(pushButton1);
 198   DALI_TEST_CHECK(pushButton1 == manager.GetCurrentFocusControl());
 199 }
 200
 201 static void UtcDaliKeyInputFocusManagerRemoveFocus()
 202 {
 203   ToolkitTestApplication application;
 204   Stage stage = Stage::GetCurrent();
 205
 206   tet_infoline(" UtcDaliKeyInputFocusManagerRemoveFocus");
 207
 208   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 209   DALI_TEST_CHECK(manager);
 210
 211   PushButton pushButton1 = PushButton::New();
 212   PushButton pushButton2 = PushButton::New();
 213   stage.Add( pushButton1 );
 214   stage.Add( pushButton2 );
 215
 216   manager.SetFocus(pushButton1);
 217   DALI_TEST_CHECK(pushButton1 == manager.GetCurrentFocusControl());
 218
 219   manager.SetFocus(pushButton2);
 220   DALI_TEST_CHECK(pushButton2 == manager.GetCurrentFocusControl());
 221
 222   manager.RemoveFocus(pushButton2);
 223   DALI_TEST_CHECK(pushButton1 == manager.GetCurrentFocusControl());
 224
 225   manager.RemoveFocus(pushButton1);
 226   DALI_TEST_CHECK(Control() == manager.GetCurrentFocusControl());
 227 }
 228
 229 static void UtcDaliKeyInputFocusManagerIsKeyboardListener()
 230 {
 231   ToolkitTestApplication application;
 232   Stage stage = Stage::GetCurrent();
 233
 234   tet_infoline(" UtcDaliKeyInputFocusManagerIsKeyboardListener");
 235
 236   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 237   DALI_TEST_CHECK(manager);
 238
 239   PushButton pushButton1 = PushButton::New();
 240   PushButton pushButton2 = PushButton::New();
 241   stage.Add( pushButton1 );
 242   stage.Add( pushButton2 );
 243
 244   manager.SetFocus(pushButton1);
 245   DALI_TEST_CHECK(pushButton1 == manager.GetCurrentFocusControl());
 246
 247   manager.SetFocus(pushButton2);
 248   DALI_TEST_CHECK(pushButton2 == manager.GetCurrentFocusControl());
 249
 250   DALI_TEST_CHECK(manager.IsKeyboardListener(pushButton1));
 251   DALI_TEST_CHECK(manager.IsKeyboardListener(pushButton2));
 252
 253   manager.RemoveFocus(pushButton2);
 254   DALI_TEST_CHECK(!manager.IsKeyboardListener(pushButton2));
 255
 256   manager.RemoveFocus(pushButton1);
 257   DALI_TEST_CHECK(!manager.IsKeyboardListener(pushButton1));
 258
 259   manager.SetFocus(pushButton2);
 260   DALI_TEST_CHECK(manager.IsKeyboardListener(pushButton2));
 261   pushButton2.ClearKeyInputFocus();
 262   DALI_TEST_CHECK(!manager.IsKeyboardListener(pushButton2));
 263 }
 264
 265 static void UtcDaliKeyInputFocusManagerSignalKeyInputFocusChanged()
 266 {
 267   ToolkitTestApplication application;
 268   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 269   Stage stage = Stage::GetCurrent();
 270
 271   tet_infoline(" UtcDaliKeyInputFocusManagerSignalKeyInputFocusChanged");
 272
 273   PushButton pushButton1 = PushButton::New();
 274   PushButton pushButton2 = PushButton::New();
 275
 276   stage.Add( pushButton1 );
 277   stage.Add( pushButton2 );
 278
 279   PushButton gainActor, lostActor;
 280   KeyInputFocusChangedCallback callback( gainActor, lostActor );
 281   manager.KeyInputFocusChangedSignal().Connect( &callback, &KeyInputFocusChangedCallback::Callback );
 282
 283   manager.SetFocus(pushButton1);
 284
 285   DALI_TEST_CHECK( gainActor == pushButton1 );
 286   DALI_TEST_CHECK( lostActor == Control() );
 287
 288   gainActor = lostActor = NULL;
 289
 290   manager.SetFocus(pushButton2);
 291
 292   DALI_TEST_CHECK( gainActor == pushButton2 );
 293   DALI_TEST_CHECK( lostActor == pushButton1 );
 294
 295   gainActor = lostActor = NULL;
 296
 297   // Removing the focus actor from the stage would also result in signal emission.
 298   stage.Remove( pushButton1 );
 299   stage.Remove( pushButton2 );
 300
 301   DALI_TEST_CHECK( gainActor == Control() );
 302   DALI_TEST_CHECK( lostActor == Control() );
 303 }
 304
 305 static void UtcDaliKeyInputFocusManagerSignalUnhandledKeyEvent()
 306 {
 307   ToolkitTestApplication application;
 308
 309   tet_infoline("UtcDaliKeyInputFocusManagerSignalUnhandledKeyEvent");
 310
 311   SignalData data;
 312   SignalUnhandledKeyEventCallback callback( data );
 313
 314   KeyInputFocusManager manager = KeyInputFocusManager::Get();
 315   manager.UnhandledKeyEventSignal().Connect( &callback, &SignalUnhandledKeyEventCallback::Callback );
 316
 317
 318   Integration::KeyEvent event("a", "a", 0, 0, 0, Integration::KeyEvent::Up);
 319   application.ProcessEvent(event);
 320
 321   DALI_TEST_CHECK(data.functorCalled);
 322   DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.keyPressedName );
 323   DALI_TEST_CHECK(event.keyCode == data.receivedKeyEvent.keyCode);
 324   DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.keyPressed );
 325   DALI_TEST_CHECK(event.state == data.receivedKeyEvent.state );
 326
 327   data.Reset();
 328
 329   Integration::KeyEvent event2("v", "v", 0, 0, 0, Integration::KeyEvent::Up);
 330   application.ProcessEvent(event2);
 331
 332   DALI_TEST_CHECK(data.functorCalled);
 333   DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.keyPressedName );
 334   DALI_TEST_CHECK(event2.keyCode == data.receivedKeyEvent.keyCode);
 335   DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.keyPressed );
 336 }