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

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