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

   1 /*
   2  * Copyright (c) 2022 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 <stdlib.h>
  19 #include <iostream>
  20
  21 #include <dali-toolkit-test-suite-utils.h>
  22
  23 #include <dali-toolkit/dali-toolkit.h>
  24 #include <dali/devel-api/actors/actor-devel.h>
  25
  26 using namespace Dali;
  27 using namespace Toolkit;
  28
  29 void dali_flexflexContainer_startup(void)
  30 {
  31   test_return_value = TET_UNDEF;
  32 }
  33
  34 void dali_flexflexContainer_cleanup(void)
  35 {
  36   test_return_value = TET_PASS;
  37 }
  38
  39 namespace
  40 {
  41 const char* const PROPERTY_NAME_CONTENT_DIRECTION = "contentDirection";
  42 const char* const PROPERTY_NAME_FLEX_DIRECTION    = "flexDirection";
  43 const char* const PROPERTY_NAME_FLEX_WRAP         = "flexWrap";
  44 const char* const PROPERTY_NAME_JUSTIFY_CONTENT   = "justifyContent";
  45 const char* const PROPERTY_NAME_ALIGN_ITEMS       = "alignItems";
  46 const char* const PROPERTY_NAME_ALIGN_CONTENT     = "alignContent";
  47 const char* const CHILD_PROPERTY_NAME_FLEX        = "flex";
  48 const char* const CHILD_PROPERTY_NAME_ALIGN_SELF  = "alignSelf";
  49 const char* const CHILD_PROPERTY_NAME_FLEX_MARGIN = "flexMargin";
  50
  51 } // namespace
  52
  53 int UtcDaliToolkitFlexContainerConstructorP(void)
  54 {
  55   ToolkitTestApplication application;
  56   tet_infoline(" UtcDaliToolkitFlexContainerConstructorP");
  57   FlexContainer flexContainer;
  58   DALI_TEST_CHECK(!flexContainer);
  59   END_TEST;
  60 }
  61
  62 int UtcDaliToolkitFlexContainerNewP(void)
  63 {
  64   ToolkitTestApplication application;
  65   tet_infoline(" UtcDaliToolkitFlexContainerNewP");
  66   FlexContainer flexContainer = FlexContainer::New();
  67   DALI_TEST_CHECK(flexContainer);
  68   END_TEST;
  69 }
  70
  71 int UtcDaliToolkitFlexContainerDownCastP(void)
  72 {
  73   ToolkitTestApplication application;
  74   tet_infoline(" UtcDaliToolkitFlexContainerDownCastP");
  75   FlexContainer flexContainer1 = FlexContainer::New();
  76   BaseHandle    object(flexContainer1);
  77
  78   FlexContainer flexContainer2 = FlexContainer::DownCast(object);
  79   DALI_TEST_CHECK(flexContainer2);
  80
  81   FlexContainer flexContainer3 = DownCast<FlexContainer>(object);
  82   DALI_TEST_CHECK(flexContainer3);
  83   END_TEST;
  84 }
  85
  86 int UtcDaliToolkitFlexContainerDownCastN(void)
  87 {
  88   ToolkitTestApplication application;
  89   tet_infoline(" UtcDaliToolkitFlexContainerDownCastN");
  90   BaseHandle    uninitializedObject;
  91   FlexContainer flexContainer1 = FlexContainer::DownCast(uninitializedObject);
  92   DALI_TEST_CHECK(!flexContainer1);
  93
  94   FlexContainer flexContainer2 = DownCast<FlexContainer>(uninitializedObject);
  95   DALI_TEST_CHECK(!flexContainer2);
  96   END_TEST;
  97 }
  98
  99 int UtcDaliToolkitFlexContainerCopyConstructorP(void)
 100 {
 101   ToolkitTestApplication application;
 102   tet_infoline(" UtcDaliToolkitFlexContainerCopyConstructorP");
 103   FlexContainer flexContainer = FlexContainer::New();
 104   flexContainer.SetProperty(FlexContainer::Property::FLEX_DIRECTION, FlexContainer::ROW_REVERSE);
 105
 106   FlexContainer copy(flexContainer);
 107   DALI_TEST_CHECK(copy);
 108   DALI_TEST_CHECK(copy.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION) == flexContainer.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION));
 109
 110   END_TEST;
 111 }
 112
 113 int UtcDaliFlexContainerMoveConstructor(void)
 114 {
 115   ToolkitTestApplication application;
 116
 117   FlexContainer flexContainer = FlexContainer::New();
 118   DALI_TEST_EQUALS(1, flexContainer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 119   flexContainer.SetProperty(FlexContainer::Property::FLEX_DIRECTION, FlexContainer::ROW_REVERSE);
 120   DALI_TEST_CHECK(flexContainer.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION) == FlexContainer::ROW_REVERSE);
 121
 122   FlexContainer moved = std::move(flexContainer);
 123   DALI_TEST_CHECK(moved);
 124   DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 125   DALI_TEST_CHECK(moved.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION) == FlexContainer::ROW_REVERSE);
 126   DALI_TEST_CHECK(!flexContainer);
 127
 128   END_TEST;
 129 }
 130
 131 int UtcDaliToolkitFlexContainerAssignmentOperatorP(void)
 132 {
 133   ToolkitTestApplication application;
 134   tet_infoline(" UtcDaliToolkitFlexContainerAssingmentOperatorP");
 135   FlexContainer flexContainer = FlexContainer::New();
 136   flexContainer.SetProperty(FlexContainer::Property::FLEX_DIRECTION, FlexContainer::ROW_REVERSE);
 137
 138   FlexContainer copy = flexContainer;
 139   DALI_TEST_CHECK(copy);
 140   DALI_TEST_CHECK(copy.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION) == flexContainer.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION));
 141   END_TEST;
 142 }
 143
 144 int UtcDaliFlexContainerMoveAssignment(void)
 145 {
 146   ToolkitTestApplication application;
 147
 148   FlexContainer flexContainer = FlexContainer::New();
 149   DALI_TEST_EQUALS(1, flexContainer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 150   flexContainer.SetProperty(FlexContainer::Property::FLEX_DIRECTION, FlexContainer::ROW_REVERSE);
 151   DALI_TEST_CHECK(flexContainer.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION) == FlexContainer::ROW_REVERSE);
 152
 153   FlexContainer moved;
 154   moved = std::move(flexContainer);
 155   DALI_TEST_CHECK(moved);
 156   DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 157   DALI_TEST_CHECK(moved.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION) == FlexContainer::ROW_REVERSE);
 158   DALI_TEST_CHECK(!flexContainer);
 159
 160   END_TEST;
 161 }
 162
 163 // Positive test case for a method
 164 int UtcDaliToolkitFlexContainerGetPropertyP(void)
 165 {
 166   ToolkitTestApplication application;
 167   tet_infoline(" UtcDaliToolkitFlexContainerGetPropertyP");
 168   FlexContainer flexContainer = FlexContainer::New();
 169   DALI_TEST_CHECK(flexContainer);
 170
 171   // Check Property Indices are correct
 172   DALI_TEST_CHECK(flexContainer.GetPropertyIndex(PROPERTY_NAME_CONTENT_DIRECTION) == FlexContainer::Property::CONTENT_DIRECTION);
 173   DALI_TEST_CHECK(flexContainer.GetPropertyIndex(PROPERTY_NAME_FLEX_DIRECTION) == FlexContainer::Property::FLEX_DIRECTION);
 174   DALI_TEST_CHECK(flexContainer.GetPropertyIndex(PROPERTY_NAME_FLEX_WRAP) == FlexContainer::Property::FLEX_WRAP);
 175   DALI_TEST_CHECK(flexContainer.GetPropertyIndex(PROPERTY_NAME_JUSTIFY_CONTENT) == FlexContainer::Property::JUSTIFY_CONTENT);
 176   DALI_TEST_CHECK(flexContainer.GetPropertyIndex(PROPERTY_NAME_ALIGN_ITEMS) == FlexContainer::Property::ALIGN_ITEMS);
 177   DALI_TEST_CHECK(flexContainer.GetPropertyIndex(PROPERTY_NAME_ALIGN_CONTENT) == FlexContainer::Property::ALIGN_CONTENT);
 178
 179   END_TEST;
 180 }
 181
 182 int UtcDaliToolkitFlexContainerSetPropertyP(void)
 183 {
 184   ToolkitTestApplication application;
 185   tet_infoline(" UtcDaliToolkitFlexContainerSetPropertyP");
 186   FlexContainer flexContainer = FlexContainer::New();
 187   DALI_TEST_CHECK(flexContainer);
 188
 189   // Add flex container to the stage
 190   application.GetScene().Add(flexContainer);
 191
 192   // Create two actors and add them to the container
 193   Actor actor1 = Actor::New();
 194   Actor actor2 = Actor::New();
 195   DALI_TEST_CHECK(actor1);
 196   DALI_TEST_CHECK(actor2);
 197
 198   flexContainer.Add(actor1);
 199   flexContainer.Add(actor2);
 200
 201   // Check content direction property.
 202   flexContainer.SetProperty(FlexContainer::Property::CONTENT_DIRECTION, FlexContainer::RTL);
 203   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::RTL, TEST_LOCATION);
 204
 205   // Check flex direction property.
 206   flexContainer.SetProperty(FlexContainer::Property::FLEX_DIRECTION, FlexContainer::COLUMN_REVERSE);
 207   DALI_TEST_EQUALS((FlexContainer::FlexDirection)flexContainer.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION), FlexContainer::COLUMN_REVERSE, TEST_LOCATION);
 208
 209   // Check flex wrap property.
 210   flexContainer.SetProperty(FlexContainer::Property::FLEX_WRAP, FlexContainer::WRAP);
 211   DALI_TEST_EQUALS((FlexContainer::WrapType)flexContainer.GetProperty<int>(FlexContainer::Property::FLEX_WRAP), FlexContainer::WRAP, TEST_LOCATION);
 212
 213   // Check justify content property.
 214   flexContainer.SetProperty(FlexContainer::Property::JUSTIFY_CONTENT, FlexContainer::JUSTIFY_SPACE_BETWEEN);
 215   DALI_TEST_EQUALS((FlexContainer::Justification)flexContainer.GetProperty<int>(FlexContainer::Property::JUSTIFY_CONTENT), FlexContainer::JUSTIFY_SPACE_BETWEEN, TEST_LOCATION);
 216
 217   // Check align items property.
 218   flexContainer.SetProperty(FlexContainer::Property::ALIGN_ITEMS, FlexContainer::ALIGN_FLEX_START);
 219   DALI_TEST_EQUALS((FlexContainer::Alignment)flexContainer.GetProperty<int>(FlexContainer::Property::ALIGN_ITEMS), FlexContainer::ALIGN_FLEX_START, TEST_LOCATION);
 220
 221   // Check align content property.
 222   flexContainer.SetProperty(FlexContainer::Property::ALIGN_CONTENT, FlexContainer::ALIGN_STRETCH);
 223   DALI_TEST_EQUALS((FlexContainer::Alignment)flexContainer.GetProperty<int>(FlexContainer::Property::ALIGN_CONTENT), FlexContainer::ALIGN_STRETCH, TEST_LOCATION);
 224
 225   END_TEST;
 226 }
 227
 228 int UtcDaliToolkitFlexContainerSetPropertyEnumP(void)
 229 {
 230   ToolkitTestApplication application;
 231   tet_infoline(" UtcDaliToolkitFlexContainerSetPropertyEnumP");
 232   FlexContainer flexContainer = FlexContainer::New();
 233   DALI_TEST_CHECK(flexContainer);
 234
 235   // Add flex container to the stage
 236   application.GetScene().Add(flexContainer);
 237
 238   // Create two actors and add them to the container
 239   Actor actor1 = Actor::New();
 240   Actor actor2 = Actor::New();
 241   DALI_TEST_CHECK(actor1);
 242   DALI_TEST_CHECK(actor2);
 243
 244   flexContainer.Add(actor1);
 245   flexContainer.Add(actor2);
 246
 247   // Check content direction property.
 248   flexContainer.SetProperty(FlexContainer::Property::CONTENT_DIRECTION, "RTL");
 249   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::RTL, TEST_LOCATION);
 250
 251   // Check flex direction property.
 252   flexContainer.SetProperty(FlexContainer::Property::FLEX_DIRECTION, "columnReverse");
 253   DALI_TEST_EQUALS((FlexContainer::FlexDirection)flexContainer.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION), FlexContainer::COLUMN_REVERSE, TEST_LOCATION);
 254
 255   // Check flex wrap property.
 256   flexContainer.SetProperty(FlexContainer::Property::FLEX_WRAP, "wrap");
 257   DALI_TEST_EQUALS((FlexContainer::WrapType)flexContainer.GetProperty<int>(FlexContainer::Property::FLEX_WRAP), FlexContainer::WRAP, TEST_LOCATION);
 258
 259   // Check justify content property.
 260   flexContainer.SetProperty(FlexContainer::Property::JUSTIFY_CONTENT, "spaceBetween");
 261   DALI_TEST_EQUALS((FlexContainer::Justification)flexContainer.GetProperty<int>(FlexContainer::Property::JUSTIFY_CONTENT), FlexContainer::JUSTIFY_SPACE_BETWEEN, TEST_LOCATION);
 262
 263   // Check align items property.
 264   flexContainer.SetProperty(FlexContainer::Property::ALIGN_ITEMS, "flexStart");
 265   DALI_TEST_EQUALS((FlexContainer::Alignment)flexContainer.GetProperty<int>(FlexContainer::Property::ALIGN_ITEMS), FlexContainer::ALIGN_FLEX_START, TEST_LOCATION);
 266
 267   // Check align content property.
 268   flexContainer.SetProperty(FlexContainer::Property::ALIGN_CONTENT, "stretch");
 269   DALI_TEST_EQUALS((FlexContainer::Alignment)flexContainer.GetProperty<int>(FlexContainer::Property::ALIGN_CONTENT), FlexContainer::ALIGN_STRETCH, TEST_LOCATION);
 270
 271   END_TEST;
 272 }
 273
 274 int UtcDaliToolkitFlexContainerSetChildPropertyP(void)
 275 {
 276   ToolkitTestApplication application;
 277   tet_infoline(" UtcDaliToolkitFlexContainerSetChildPropertyP");
 278   FlexContainer flexContainer = FlexContainer::New();
 279   DALI_TEST_CHECK(flexContainer);
 280
 281   // Add flex container to the stage
 282   application.GetScene().Add(flexContainer);
 283
 284   // Create an actor and add it to the container
 285   Actor actor = Actor::New();
 286   DALI_TEST_CHECK(actor);
 287
 288   flexContainer.Add(actor);
 289
 290   // Check flex child property.
 291   actor.SetProperty(FlexContainer::ChildProperty::FLEX, 2.0f);
 292   DALI_TEST_EQUALS(actor.GetProperty<float>(FlexContainer::ChildProperty::FLEX), 2.0f, TEST_LOCATION);
 293   DALI_TEST_CHECK(actor.GetPropertyIndex(CHILD_PROPERTY_NAME_FLEX) == FlexContainer::ChildProperty::FLEX);
 294
 295   // Check align self child property.
 296   actor.SetProperty(FlexContainer::ChildProperty::ALIGN_SELF, FlexContainer::ALIGN_FLEX_END);
 297   DALI_TEST_EQUALS((FlexContainer::Alignment)actor.GetProperty<int>(FlexContainer::ChildProperty::ALIGN_SELF), FlexContainer::ALIGN_FLEX_END, TEST_LOCATION);
 298   DALI_TEST_CHECK(actor.GetPropertyIndex(CHILD_PROPERTY_NAME_ALIGN_SELF) == FlexContainer::ChildProperty::ALIGN_SELF);
 299
 300   // Check flex margin child property.
 301   actor.SetProperty(FlexContainer::ChildProperty::FLEX_MARGIN, Vector4(10.0f, 10.0f, 10.0f, 10.0f));
 302   DALI_TEST_EQUALS(actor.GetProperty<Vector4>(FlexContainer::ChildProperty::FLEX_MARGIN), Vector4(10.0f, 10.0f, 10.0f, 10.0f), TEST_LOCATION);
 303   DALI_TEST_CHECK(actor.GetPropertyIndex(CHILD_PROPERTY_NAME_FLEX_MARGIN) == FlexContainer::ChildProperty::FLEX_MARGIN);
 304
 305   application.SendNotification();
 306   application.Render();
 307
 308   END_TEST;
 309 }
 310
 311 //Functor to test whether RelayoutSignal is emitted
 312 class RelayoutSignalHandler : public Dali::ConnectionTracker
 313 {
 314 public:
 315   RelayoutSignalHandler(FlexContainer& actor)
 316   : mSignalVerified(false),
 317     mActor(actor)
 318   {
 319   }
 320
 321   // callback to be connected to RelayoutSignal
 322   void RelayoutCallback(Actor actor)
 323   {
 324     if(mActor == actor)
 325     {
 326       mSignalVerified = true;
 327     }
 328   }
 329
 330   void Reset()
 331   {
 332     mSignalVerified = false;
 333   }
 334
 335   bool   mSignalVerified;
 336   Actor& mActor;
 337 };
 338
 339 int UtcDaliToolkitFlexContainerRemoveChildP(void)
 340 {
 341   ToolkitTestApplication application;
 342   tet_infoline(" UtcDaliToolkitFlexContainerSetPropertyP");
 343   FlexContainer flexContainer = FlexContainer::New();
 344   DALI_TEST_CHECK(flexContainer);
 345
 346   // Add flex container to the stage
 347   application.GetScene().Add(flexContainer);
 348
 349   RelayoutSignalHandler relayoutSignal(flexContainer);
 350   flexContainer.OnRelayoutSignal().Connect(&relayoutSignal, &RelayoutSignalHandler::RelayoutCallback);
 351
 352   // Create two actors and add them to the container
 353   Actor actor1 = Actor::New();
 354   Actor actor2 = Actor::New();
 355   DALI_TEST_CHECK(actor1);
 356   DALI_TEST_CHECK(actor2);
 357
 358   flexContainer.Add(actor1);
 359   flexContainer.Add(actor2);
 360
 361   application.SendNotification();
 362   application.Render();
 363
 364   DALI_TEST_EQUALS(relayoutSignal.mSignalVerified, true, TEST_LOCATION);
 365   relayoutSignal.Reset();
 366
 367   DALI_TEST_CHECK(actor1);
 368   DALI_TEST_CHECK(actor2);
 369
 370   flexContainer.Remove(actor1);
 371   application.SendNotification();
 372   application.Render();
 373   DALI_TEST_EQUALS(relayoutSignal.mSignalVerified, true, TEST_LOCATION);
 374   relayoutSignal.Reset();
 375
 376   flexContainer.Remove(actor2);
 377   application.SendNotification();
 378   application.Render();
 379   DALI_TEST_EQUALS(relayoutSignal.mSignalVerified, true, TEST_LOCATION);
 380   relayoutSignal.Reset();
 381
 382   END_TEST;
 383 }
 384
 385 namespace
 386 {
 387 // Functors to test whether PreFocusChange signal is emitted when the keyboard focus is about to change
 388 class PreFocusChangeCallback : public Dali::ConnectionTracker
 389 {
 390 public:
 391   PreFocusChangeCallback(bool& signalReceived, Actor firstFocusActor)
 392   : mSignalVerified(signalReceived),
 393     mFirstFocusActor(firstFocusActor),
 394     mDirection(Control::KeyboardFocus::LEFT)
 395   {
 396   }
 397
 398   Actor Callback(Actor currentFocusedActor, Actor proposedActorToFocus, Control::KeyboardFocus::Direction direction)
 399   {
 400     tet_infoline("Verifying PreFocusChangeCallback()");
 401
 402     mSignalVerified = true;
 403     mDirection      = direction;
 404     if(!proposedActorToFocus)
 405     {
 406       return mFirstFocusActor;
 407     }
 408     else
 409     {
 410       return proposedActorToFocus;
 411     }
 412   }
 413
 414   void Reset()
 415   {
 416     mSignalVerified = false;
 417     mDirection      = Control::KeyboardFocus::LEFT;
 418   }
 419
 420   bool&                             mSignalVerified;
 421   Actor                             mFirstFocusActor;
 422   Control::KeyboardFocus::Direction mDirection;
 423 };
 424
 425 // Functors to test whether focus changed signal is emitted when the keyboard focus is changed
 426 class FocusChangedCallback : public Dali::ConnectionTracker
 427 {
 428 public:
 429   FocusChangedCallback(bool& signalReceived)
 430   : mSignalVerified(signalReceived),
 431     mOriginalFocusedActor(),
 432     mCurrentFocusedActor()
 433   {
 434   }
 435
 436   void Callback(Actor originalFocusedActor, Actor currentFocusedActor)
 437   {
 438     tet_infoline("Verifying FocusChangedCallback()");
 439
 440     if(originalFocusedActor == mCurrentFocusedActor)
 441     {
 442       mSignalVerified = true;
 443     }
 444
 445     mOriginalFocusedActor = originalFocusedActor;
 446     mCurrentFocusedActor  = currentFocusedActor;
 447   }
 448
 449   void Reset()
 450   {
 451     mSignalVerified = false;
 452   }
 453
 454   bool& mSignalVerified;
 455   Actor mOriginalFocusedActor;
 456   Actor mCurrentFocusedActor;
 457 };
 458
 459 } // anonymous namespace
 460
 461 int UtcDaliToolkitFlexContainerMoveFocus(void)
 462 {
 463   ToolkitTestApplication application;
 464   tet_infoline(" UtcDaliToolkitFlexContainerSetPropertyP");
 465   FlexContainer flexContainer = FlexContainer::New();
 466   DALI_TEST_CHECK(flexContainer);
 467
 468   flexContainer.SetProperty(FlexContainer::Property::FLEX_DIRECTION, FlexContainer::ROW);
 469
 470   // Add flex container to the stage
 471   application.GetScene().Add(flexContainer);
 472   Size stageSize = application.GetScene().GetSize();
 473
 474   RelayoutSignalHandler relayoutSignal(flexContainer);
 475   flexContainer.OnRelayoutSignal().Connect(&relayoutSignal, &RelayoutSignalHandler::RelayoutCallback);
 476   flexContainer.SetProperty(Actor::Property::SIZE, stageSize);
 477
 478   // Create two actors and add them to the container
 479   Actor actor1 = Actor::New();
 480   Actor actor2 = Actor::New();
 481   actor1.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 482   actor2.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
 483   DALI_TEST_CHECK(actor1);
 484   DALI_TEST_CHECK(actor2);
 485
 486   flexContainer.Add(actor1);
 487   flexContainer.Add(actor2);
 488
 489   application.SendNotification();
 490   application.Render();
 491
 492   KeyboardFocusManager manager = KeyboardFocusManager::Get();
 493   DALI_TEST_CHECK(manager);
 494
 495   bool                   preFocusChangeSignalVerified = false;
 496   PreFocusChangeCallback preFocusChangeCallback(preFocusChangeSignalVerified, actor1);
 497   manager.PreFocusChangeSignal().Connect(&preFocusChangeCallback, &PreFocusChangeCallback::Callback);
 498
 499   bool                 focusChangedSignalVerified = false;
 500   FocusChangedCallback focusChangedCallback(focusChangedSignalVerified);
 501   manager.FocusChangedSignal().Connect(&focusChangedCallback, &FocusChangedCallback::Callback);
 502
 503   // Move the focus to the right
 504   DALI_TEST_EQUALS(manager.MoveFocus(Control::KeyboardFocus::RIGHT), true, TEST_LOCATION);
 505   DALI_TEST_CHECK(preFocusChangeCallback.mSignalVerified);
 506   DALI_TEST_EQUALS(manager.GetCurrentFocusActor(), actor1, TEST_LOCATION);
 507   preFocusChangeCallback.Reset();
 508   DALI_TEST_EQUALS(focusChangedCallback.mCurrentFocusedActor, actor1, TEST_LOCATION);
 509   focusChangedCallback.Reset();
 510
 511   // Move the focus towards right
 512   DALI_TEST_EQUALS(manager.MoveFocus(Control::KeyboardFocus::RIGHT), true, TEST_LOCATION);
 513   DALI_TEST_EQUALS(preFocusChangeCallback.mSignalVerified, true, TEST_LOCATION);
 514   DALI_TEST_EQUALS(manager.GetCurrentFocusActor(), actor2, TEST_LOCATION);
 515   DALI_TEST_EQUALS(focusChangedCallback.mSignalVerified, true, TEST_LOCATION);
 516   DALI_TEST_EQUALS(focusChangedCallback.mCurrentFocusedActor, actor2, TEST_LOCATION);
 517
 518   preFocusChangeCallback.Reset();
 519   focusChangedCallback.Reset();
 520
 521   // Move the focus towards left
 522   DALI_TEST_EQUALS(manager.MoveFocus(Control::KeyboardFocus::LEFT), true, TEST_LOCATION);
 523   DALI_TEST_EQUALS(preFocusChangeCallback.mSignalVerified, true, TEST_LOCATION);
 524   DALI_TEST_EQUALS(manager.GetCurrentFocusActor(), actor1, TEST_LOCATION);
 525   DALI_TEST_EQUALS(focusChangedCallback.mSignalVerified, true, TEST_LOCATION);
 526   DALI_TEST_EQUALS(focusChangedCallback.mCurrentFocusedActor, actor1, TEST_LOCATION);
 527
 528   END_TEST;
 529 }
 530
 531 int UtcDaliToolkitFlexContainerRTLSupportP(void)
 532 {
 533   ToolkitTestApplication application;
 534   tet_infoline(" UtcDaliToolkitFlexContainerRTLSupportP");
 535   FlexContainer flexContainer = FlexContainer::New();
 536   DALI_TEST_CHECK(flexContainer);
 537
 538   Actor actor0 = Actor::New();
 539
 540   application.GetScene().Add(actor0);
 541   actor0.Add(flexContainer);
 542
 543   // Create two actors and add them to the container
 544   Actor actor1 = Actor::New();
 545   Actor actor2 = Actor::New();
 546   DALI_TEST_CHECK(actor1);
 547   DALI_TEST_CHECK(actor2);
 548
 549   flexContainer.Add(actor1);
 550   flexContainer.Add(actor2);
 551
 552   // Check flex direction property.
 553   flexContainer.SetProperty(FlexContainer::Property::FLEX_DIRECTION, "row");
 554   DALI_TEST_EQUALS((FlexContainer::FlexDirection)flexContainer.GetProperty<int>(FlexContainer::Property::FLEX_DIRECTION), FlexContainer::ROW, TEST_LOCATION);
 555
 556   // Check content direction property.
 557   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::INHERIT, TEST_LOCATION);
 558
 559   actor0.SetProperty(Dali::Actor::Property::LAYOUT_DIRECTION, Dali::LayoutDirection::RIGHT_TO_LEFT);
 560   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::RTL, TEST_LOCATION);
 561
 562   actor0.SetProperty(Dali::Actor::Property::LAYOUT_DIRECTION, Dali::LayoutDirection::LEFT_TO_RIGHT);
 563   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::LTR, TEST_LOCATION);
 564
 565   flexContainer.SetProperty(FlexContainer::Property::CONTENT_DIRECTION, "RTL");
 566   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::RTL, TEST_LOCATION);
 567
 568   flexContainer.SetProperty(FlexContainer::Property::CONTENT_DIRECTION, "LTR");
 569   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::LTR, TEST_LOCATION);
 570
 571   actor0.SetProperty(Dali::Actor::Property::LAYOUT_DIRECTION, Dali::LayoutDirection::RIGHT_TO_LEFT);
 572   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::LTR, TEST_LOCATION);
 573
 574   flexContainer.SetProperty(FlexContainer::Property::CONTENT_DIRECTION, "inherit");
 575   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::RTL, TEST_LOCATION);
 576
 577   actor0.SetProperty(Dali::Actor::Property::LAYOUT_DIRECTION, Dali::LayoutDirection::LEFT_TO_RIGHT);
 578   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::LTR, TEST_LOCATION);
 579
 580   flexContainer.SetProperty(FlexContainer::Property::CONTENT_DIRECTION, "inherit");
 581   DALI_TEST_EQUALS((FlexContainer::ContentDirection)flexContainer.GetProperty<int>(FlexContainer::Property::CONTENT_DIRECTION), FlexContainer::LTR, TEST_LOCATION);
 582
 583   flexContainer.SetProperty(FlexContainer::Property::CONTENT_DIRECTION, "LTR");
 584   application.SendNotification();
 585   application.Render();
 586
 587   flexContainer.SetProperty(FlexContainer::Property::CONTENT_DIRECTION, "RTL");
 588   application.SendNotification();
 589   application.Render();
 590
 591   END_TEST;
 592 }