automated-tests/src/dali/utc-Dali-FrameCallbackInterface.cpp

   1 /*
   2  * Copyright (c) 2024 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 <dali-test-suite-utils.h>
  19 #include <dali/devel-api/actors/actor-devel.h>
  20 #include <dali/devel-api/common/map-wrapper.h>
  21 #include <dali/devel-api/common/stage-devel.h>
  22 #include <dali/devel-api/update/frame-callback-interface.h>
  23 #include <dali/devel-api/update/update-proxy.h>
  24 #include <dali/public-api/dali-core.h>
  25 #include <stdlib.h>
  26
  27 #include <iostream>
  28
  29 using namespace Dali;
  30
  31 void utc_dali_frame_callback_interface_startup(void)
  32 {
  33   test_return_value = TET_UNDEF;
  34 }
  35
  36 void utc_dali_frame_callback_interface_cleanup(void)
  37 {
  38   test_return_value = TET_PASS;
  39 }
  40
  41 ///////////////////////////////////////////////////////////////////////////////
  42 namespace
  43 {
  44 class FrameCallbackBasic : public FrameCallbackInterface
  45 {
  46 public:
  47   FrameCallbackBasic() = default;
  48
  49   virtual bool Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds)
  50   {
  51     mCalled = true;
  52     return true;
  53   }
  54
  55   virtual void Reset()
  56   {
  57     mCalled = false;
  58   }
  59
  60   bool mCalled{false};
  61 };
  62
  63 class FrameCallbackOneActor : public FrameCallbackBasic
  64 {
  65 public:
  66   FrameCallbackOneActor(unsigned int actorId)
  67   : mActorId(actorId)
  68   {
  69   }
  70
  71   virtual bool Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
  72   {
  73     FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
  74     updateProxy.GetPosition(mActorId, mPositionGetPositionCall);
  75     updateProxy.GetPositionAndSize(mActorId, mPositionGetPositionAndSizeCall, mSizeGetPositionAndSizeCall);
  76     updateProxy.GetSize(mActorId, mSizeGetSizeCall);
  77     updateProxy.GetOrientation(mActorId, mOrientation);
  78     updateProxy.GetColor(mActorId, mColor);
  79     updateProxy.GetScale(mActorId, mScale);
  80
  81     updateProxy.GetWorldPositionScaleAndSize(mActorId, mWorldPosition, mWorldScale, mSizeGetWorldPositionAndSizeCall);
  82     updateProxy.GetWorldTransformAndSize(mActorId, mWorldTransformPosition, mWorldTransformScale, mWorldTransformOrientation, mSizeGetWorldTransform);
  83
  84     return false;
  85   }
  86
  87   const unsigned int mActorId;
  88
  89   Vector3    mPositionGetPositionCall;
  90   Vector3    mPositionGetPositionAndSizeCall;
  91   Vector3    mSizeGetSizeCall;
  92   Vector3    mSizeGetPositionAndSizeCall;
  93   Vector4    mColor;
  94   Vector3    mScale;
  95   Quaternion mOrientation;
  96
  97   Vector3 mWorldPosition;
  98   Vector3 mWorldScale;
  99   Vector3 mSizeGetWorldPositionAndSizeCall;
 100
 101   Vector3    mWorldTransformPosition;
 102   Vector3    mWorldTransformScale;
 103   Quaternion mWorldTransformOrientation;
 104   Vector3    mSizeGetWorldTransform;
 105 };
 106
 107 class FrameCallbackNotify : public FrameCallbackBasic
 108 {
 109 public:
 110   FrameCallbackNotify()
 111   {
 112   }
 113
 114   void SetSyncTrigger(int trigger)
 115   {
 116     mTrigger   = trigger;
 117     mTriggered = false;
 118   }
 119
 120   virtual bool Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
 121   {
 122     FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
 123
 124     UpdateProxy::NotifySyncPoint sync;
 125     while((sync = updateProxy.PopSyncPoint()) != UpdateProxy::INVALID_SYNC)
 126     {
 127       mTriggered = (sync == mTrigger);
 128       mSyncPoints.push_back(sync);
 129     }
 130     return true;
 131   }
 132
 133   std::list<UpdateProxy::NotifySyncPoint> mSyncPoints;
 134   UpdateProxy::NotifySyncPoint            mTrigger{UpdateProxy::INVALID_SYNC};
 135   bool                                    mTriggered{false};
 136 };
 137
 138 class FrameCallbackSetter : public FrameCallbackBasic
 139 {
 140 public:
 141   FrameCallbackSetter(
 142     unsigned int      actorId,
 143     const Vector3&    sizeToSet,
 144     const Vector3&    positionToSet,
 145     const Vector4&    colorToSet,
 146     const Vector3&    scaleToSet,
 147     const Quaternion& orientationToSet,
 148     const Vector4&    updateAreaToSet)
 149   : mActorId(actorId),
 150     mSizeToSet(sizeToSet),
 151     mPositionToSet(positionToSet),
 152     mColorToSet(colorToSet),
 153     mScaleToSet(scaleToSet),
 154     mOrientationToSet(orientationToSet),
 155     mUpdateArea(updateAreaToSet)
 156   {
 157   }
 158
 159   virtual bool Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
 160   {
 161     Vector3 size;
 162     FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
 163     updateProxy.SetSize(mActorId, mSizeToSet);
 164     updateProxy.SetPosition(mActorId, mPositionToSet);
 165     updateProxy.SetOrientation(mActorId, mOrientationToSet);
 166     updateProxy.SetColor(mActorId, mColorToSet);
 167     updateProxy.SetScale(mActorId, mScaleToSet);
 168     updateProxy.SetUpdateArea(mActorId, mUpdateArea);
 169     updateProxy.GetSize(mActorId, mSizeAfterSetting);
 170     updateProxy.GetPosition(mActorId, mPositionAfterSetting);
 171     updateProxy.GetColor(mActorId, mColorAfterSetting);
 172     updateProxy.GetScale(mActorId, mScaleAfterSetting);
 173     updateProxy.GetOrientation(mActorId, mOrientationAfterSetting);
 174     updateProxy.GetUpdateArea(mActorId, mUpdateAreaAfterSetting);
 175
 176     return false;
 177   }
 178
 179   const unsigned int mActorId;
 180   const Vector3&     mSizeToSet;
 181   const Vector3&     mPositionToSet;
 182   const Vector4&     mColorToSet;
 183   const Vector3&     mScaleToSet;
 184   const Quaternion&  mOrientationToSet;
 185   const Vector4&     mUpdateArea;
 186
 187   Vector3    mSizeAfterSetting;
 188   Vector3    mPositionAfterSetting;
 189   Vector4    mColorAfterSetting;
 190   Vector3    mScaleAfterSetting;
 191   Quaternion mOrientationAfterSetting;
 192   Vector4    mUpdateAreaAfterSetting;
 193 };
 194
 195 class FrameCallbackBaker : public FrameCallbackBasic
 196 {
 197 public:
 198   FrameCallbackBaker(
 199     unsigned int      actorId,
 200     const Vector3&    sizeToSet,
 201     const Vector3&    positionToSet,
 202     const Vector4&    colorToSet,
 203     const Vector3&    scaleToSet,
 204     const Quaternion& orientationToSet)
 205   : mActorId(actorId),
 206     mSizeToSet(sizeToSet),
 207     mPositionToSet(positionToSet),
 208     mColorToSet(colorToSet),
 209     mScaleToSet(scaleToSet),
 210     mOrientationToSet(orientationToSet)
 211   {
 212   }
 213
 214   virtual bool Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
 215   {
 216     Vector3 size;
 217     FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
 218     updateProxy.BakeSize(mActorId, mSizeToSet);
 219     updateProxy.BakePosition(mActorId, mPositionToSet);
 220     updateProxy.BakeColor(mActorId, mColorToSet);
 221     updateProxy.BakeScale(mActorId, mScaleToSet);
 222     updateProxy.BakeOrientation(mActorId, mOrientationToSet);
 223     updateProxy.GetSize(mActorId, mSizeAfterSetting);
 224     updateProxy.GetPosition(mActorId, mPositionAfterSetting);
 225     updateProxy.GetColor(mActorId, mColorAfterSetting);
 226     updateProxy.GetScale(mActorId, mScaleAfterSetting);
 227     updateProxy.GetOrientation(mActorId, mOrientationAfterSetting);
 228
 229     return false;
 230   }
 231
 232   const unsigned int mActorId;
 233   const Vector3&     mSizeToSet;
 234   const Vector3&     mPositionToSet;
 235   const Vector4&     mColorToSet;
 236   const Vector3&     mScaleToSet;
 237   const Quaternion&  mOrientationToSet;
 238
 239   Vector3    mSizeAfterSetting;
 240   Vector3    mPositionAfterSetting;
 241   Vector4    mColorAfterSetting;
 242   Vector3    mScaleAfterSetting;
 243   Quaternion mOrientationAfterSetting;
 244 };
 245
 246 class FrameCallbackMultipleActors : public FrameCallbackBasic
 247 {
 248 public:
 249   FrameCallbackMultipleActors()
 250   {
 251   }
 252
 253   virtual bool Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
 254   {
 255     FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
 256     for(auto&& i : mActorIds)
 257     {
 258       Vector3 position;
 259       Vector3 size;
 260       updateProxy.GetPositionAndSize(i, position, size);
 261       mPositions[i] = position;
 262       mSizes[i]     = size;
 263     }
 264
 265     return false;
 266   }
 267
 268   Vector<unsigned int> mActorIds;
 269
 270   std::map<unsigned int, Vector3> mPositions;
 271   std::map<unsigned int, Vector3> mSizes;
 272 };
 273
 274 class FrameCallbackActorIdCheck : public FrameCallbackBasic
 275 {
 276 public:
 277   FrameCallbackActorIdCheck(unsigned int actorId)
 278   : mActorId(actorId)
 279   {
 280   }
 281
 282   virtual bool Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
 283   {
 284     FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
 285     Vector3    vec3;
 286     Vector4    vec4;
 287     Quaternion quat;
 288
 289     mGetSizeCallSuccess                      = updateProxy.GetSize(mActorId, vec3);
 290     mGetPositionCallSuccess                  = updateProxy.GetPosition(mActorId, vec3);
 291     mGetColorCallSuccess                     = updateProxy.GetColor(mActorId, vec4);
 292     mGetScaleCallSuccess                     = updateProxy.GetScale(mActorId, vec3);
 293     mGetPositionAndSizeCallSuccess           = updateProxy.GetPositionAndSize(mActorId, vec3, vec3);
 294     mGetWorldPositionScaleAndSizeCallSuccess = updateProxy.GetWorldPositionScaleAndSize(mActorId, vec3, vec3, vec3);
 295     mSetSizeCallSuccess                      = updateProxy.SetSize(mActorId, vec3);
 296     mSetPositionCallSuccess                  = updateProxy.SetPosition(mActorId, vec3);
 297     mSetColorCallSuccess                     = updateProxy.SetColor(mActorId, vec4);
 298     mSetScaleCallSuccess                     = updateProxy.SetScale(mActorId, vec3);
 299     mBakeSizeCallSuccess                     = updateProxy.BakeSize(mActorId, vec3);
 300     mBakePositionCallSuccess                 = updateProxy.BakePosition(mActorId, vec3);
 301     mBakeColorCallSuccess                    = updateProxy.BakeColor(mActorId, vec4);
 302     mBakeScaleCallSuccess                    = updateProxy.BakeScale(mActorId, vec3);
 303
 304     mGetOrientationCallSuccess    = updateProxy.GetOrientation(mActorId, quat);
 305     mSetOrientationCallSuccess    = updateProxy.SetOrientation(mActorId, quat);
 306     mBakeOrientationCallSuccess   = updateProxy.BakeOrientation(mActorId, quat);
 307     mGetWorldTransformCallSuccess = updateProxy.GetWorldTransformAndSize(mActorId, vec3, vec3, quat, vec3);
 308     mGetUpdateAreaCallSuccess     = updateProxy.GetUpdateArea(mActorId, vec4);
 309     mSetUpdateAreaCallSuccess     = updateProxy.SetUpdateArea(mActorId, vec4);
 310
 311     return false;
 312   }
 313
 314   virtual void Reset() override
 315   {
 316     // Up-call
 317     FrameCallbackBasic::Reset();
 318
 319     mGetSizeCallSuccess                      = false;
 320     mGetPositionCallSuccess                  = false;
 321     mGetColorCallSuccess                     = false;
 322     mGetScaleCallSuccess                     = false;
 323     mGetPositionAndSizeCallSuccess           = false;
 324     mGetWorldPositionScaleAndSizeCallSuccess = false;
 325     mSetSizeCallSuccess                      = false;
 326     mSetPositionCallSuccess                  = false;
 327     mSetColorCallSuccess                     = false;
 328     mSetScaleCallSuccess                     = false;
 329     mBakeSizeCallSuccess                     = false;
 330     mBakePositionCallSuccess                 = false;
 331     mBakeColorCallSuccess                    = false;
 332     mBakeScaleCallSuccess                    = false;
 333
 334     mSetOrientationCallSuccess  = false;
 335     mGetOrientationCallSuccess  = false;
 336     mBakeOrientationCallSuccess = false;
 337
 338     mGetWorldTransformCallSuccess = false;
 339     mGetUpdateAreaCallSuccess     = false;
 340     mSetUpdateAreaCallSuccess     = false;
 341   }
 342
 343   const uint32_t mActorId;
 344
 345   bool mGetSizeCallSuccess{false};
 346   bool mGetPositionCallSuccess{false};
 347   bool mGetOrientationCallSuccess{false};
 348   bool mGetColorCallSuccess{false};
 349   bool mGetScaleCallSuccess{false};
 350   bool mGetPositionAndSizeCallSuccess{false};
 351   bool mGetWorldPositionScaleAndSizeCallSuccess{false};
 352   bool mSetSizeCallSuccess{false};
 353   bool mSetPositionCallSuccess{false};
 354   bool mSetColorCallSuccess{false};
 355   bool mSetScaleCallSuccess{false};
 356   bool mSetOrientationCallSuccess{false};
 357   bool mBakeSizeCallSuccess{false};
 358   bool mBakePositionCallSuccess{false};
 359   bool mBakeColorCallSuccess{false};
 360   bool mBakeScaleCallSuccess{false};
 361   bool mBakeOrientationCallSuccess{false};
 362   bool mGetWorldTransformCallSuccess{false};
 363   bool mGetUpdateAreaCallSuccess{false};
 364   bool mSetUpdateAreaCallSuccess{false};
 365 };
 366
 367 } // namespace
 368
 369 ///////////////////////////////////////////////////////////////////////////////
 370
 371 int UtcDaliFrameCallbackCheckInstallationAndRemoval(void)
 372 {
 373   // Basic test to check that the frame-callback can be installed and removed correctly
 374
 375   TestApplication application;
 376
 377   FrameCallbackBasic frameCallback;
 378
 379   Stage stage = Stage::GetCurrent();
 380   DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
 381
 382   application.SendNotification();
 383   application.Render();
 384
 385   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 386
 387   frameCallback.mCalled = false;
 388
 389   DevelStage::RemoveFrameCallback(stage, frameCallback);
 390
 391   application.SendNotification();
 392   application.Render();
 393
 394   DALI_TEST_EQUALS(frameCallback.mCalled, false, TEST_LOCATION);
 395
 396   END_TEST;
 397 }
 398
 399 int UtcDaliFrameCallbackGetters(void)
 400 {
 401   // Test to see that the Getters all return the expected values
 402
 403   TestApplication application;
 404
 405   Vector2    actorSize(200, 300);
 406   Vector4    color(0.5f, 0.6f, 0.7f, 0.8f);
 407   Vector3    position(10.0f, 20.0f, 30.0f);
 408   Vector3    scale(2.0f, 4.0f, 6.0f);
 409   Quaternion orientation; //(Radian(Math::PI_2), Vector3::ZAXIS);
 410   Actor      actor = Actor::New();
 411   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
 412   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 413   actor.SetProperty(Actor::Property::SIZE, actorSize);
 414   actor.SetProperty(Actor::Property::COLOR, color);
 415   actor.SetProperty(Actor::Property::POSITION, position);
 416   actor.SetProperty(Actor::Property::SCALE, scale);
 417   actor.SetProperty(Actor::Property::ORIENTATION, orientation);
 418
 419   Stage stage = Stage::GetCurrent();
 420   stage.Add(actor);
 421
 422   FrameCallbackOneActor frameCallback(actor.GetProperty<int>(Actor::Property::ID));
 423   DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
 424
 425   application.SendNotification();
 426   application.Render();
 427
 428   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 429   DALI_TEST_EQUALS(frameCallback.mSizeGetSizeCall, Vector3(actorSize.width, actorSize.height, 0.0f), TEST_LOCATION);
 430   DALI_TEST_EQUALS(frameCallback.mPositionGetPositionCall, position, TEST_LOCATION);
 431   DALI_TEST_EQUALS(frameCallback.mPositionGetPositionAndSizeCall, position, TEST_LOCATION);
 432   DALI_TEST_EQUALS(frameCallback.mSizeGetPositionAndSizeCall, Vector3(actorSize.width, actorSize.height, 0.0f), TEST_LOCATION);
 433
 434   DALI_TEST_EQUALS(frameCallback.mColor, color, TEST_LOCATION);
 435   DALI_TEST_EQUALS(frameCallback.mScale, scale, TEST_LOCATION);
 436   DALI_TEST_EQUALS(frameCallback.mOrientation, orientation, TEST_LOCATION);
 437
 438   frameCallback.Reset();
 439
 440   application.SendNotification();
 441   application.Render();
 442
 443   Vector3    worldPosition, worldScale;
 444   Quaternion worldRotation;
 445   Matrix     worldTransform = DevelActor::GetWorldTransform(actor);
 446   worldTransform.GetTransformComponents(worldPosition, worldRotation, worldScale);
 447
 448   // World position and scale values are updated after FrameCallbackInterface::Update()
 449   // So test them after the second rendering
 450   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 451
 452   DALI_TEST_EQUALS(frameCallback.mSizeGetWorldTransform, Vector3(actorSize.width, actorSize.height, 0.0f), TEST_LOCATION);
 453   DALI_TEST_EQUALS(frameCallback.mWorldPosition, worldPosition, TEST_LOCATION);
 454   DALI_TEST_EQUALS(frameCallback.mWorldScale, worldScale, TEST_LOCATION);
 455   DALI_TEST_EQUALS(frameCallback.mSizeGetWorldPositionAndSizeCall, Vector3(actorSize), TEST_LOCATION);
 456   DALI_TEST_EQUALS(frameCallback.mWorldTransformPosition, worldPosition, TEST_LOCATION);
 457   DALI_TEST_EQUALS(frameCallback.mWorldTransformScale, worldScale, TEST_LOCATION);
 458   DALI_TEST_EQUALS(frameCallback.mWorldTransformOrientation, worldRotation, TEST_LOCATION);
 459
 460   END_TEST;
 461 }
 462
 463 int UtcDaliFrameCallbackSetters(void)
 464 {
 465   // Test to see that the setters set the values appropriately
 466
 467   TestApplication application;
 468   Vector2         actorSize(200, 300);
 469
 470   Actor actor = Actor::New();
 471   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
 472   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 473   actor.SetProperty(Actor::Property::SIZE, actorSize);
 474
 475   Stage stage = Stage::GetCurrent();
 476   stage.Add(actor);
 477
 478   Vector3    sizeToSet(1.0f, 2.0f, 3.0f);
 479   Vector3    positionToSet(10.0f, 20.0f, 30.0f);
 480   Vector4    colorToSet(Color::MAGENTA);
 481   Vector3    scaleToSet(1.0f, 3.0f, 5.0f);
 482   Quaternion orientationToSet(Radian(Math::PI_2), Vector3::ZAXIS);
 483   Vector4    updateAreaToSet(10.0f, 10.0f, 200.0f, 100.0f);
 484
 485   FrameCallbackSetter frameCallback(actor.GetProperty<int>(Actor::Property::ID), sizeToSet, positionToSet, colorToSet, scaleToSet, orientationToSet, updateAreaToSet);
 486   DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
 487
 488   application.SendNotification();
 489   application.Render();
 490
 491   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 492   DALI_TEST_EQUALS(frameCallback.mSizeAfterSetting, sizeToSet, TEST_LOCATION);
 493   DALI_TEST_EQUALS(frameCallback.mPositionAfterSetting, positionToSet, TEST_LOCATION);
 494   DALI_TEST_EQUALS(frameCallback.mColorAfterSetting, colorToSet, TEST_LOCATION);
 495   DALI_TEST_EQUALS(frameCallback.mScaleAfterSetting, scaleToSet, TEST_LOCATION);
 496   DALI_TEST_EQUALS(frameCallback.mOrientationAfterSetting, orientationToSet, TEST_LOCATION);
 497   DALI_TEST_EQUALS(frameCallback.mUpdateAreaAfterSetting, updateAreaToSet, TEST_LOCATION);
 498
 499   // Ensure the actual actor values haven't changed as we didn't bake the values after removing the callback
 500   DevelStage::RemoveFrameCallback(stage, frameCallback);
 501
 502   application.SendNotification();
 503   application.Render();
 504
 505   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), Vector3::ZERO, TEST_LOCATION);
 506   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>(), Vector3(actorSize), TEST_LOCATION);
 507   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::COLOR).Get<Vector4>(), Color::WHITE, TEST_LOCATION);
 508   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SCALE).Get<Vector3>(), Vector3::ONE, TEST_LOCATION);
 509   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::ORIENTATION).Get<Quaternion>(), Quaternion(Radian(0.0f), Vector3::ZAXIS), TEST_LOCATION);
 510
 511   // Render for a couple more frames to ensure the values are reset properly (some values are double-buffered)
 512
 513   application.SendNotification();
 514   application.Render();
 515
 516   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), Vector3::ZERO, TEST_LOCATION);
 517   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>(), Vector3(actorSize), TEST_LOCATION);
 518   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::COLOR).Get<Vector4>(), Color::WHITE, TEST_LOCATION);
 519   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SCALE).Get<Vector3>(), Vector3::ONE, TEST_LOCATION);
 520   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::ORIENTATION).Get<Quaternion>(), Quaternion(Radian(0.0f), Vector3::ZAXIS), TEST_LOCATION);
 521
 522   application.SendNotification();
 523   application.Render();
 524
 525   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), Vector3::ZERO, TEST_LOCATION);
 526   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>(), Vector3(actorSize), TEST_LOCATION);
 527   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::COLOR).Get<Vector4>(), Color::WHITE, TEST_LOCATION);
 528   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SCALE).Get<Vector3>(), Vector3::ONE, TEST_LOCATION);
 529   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::ORIENTATION).Get<Quaternion>(), Quaternion(Radian(0.0f), Vector3::ZAXIS), TEST_LOCATION);
 530
 531   END_TEST;
 532 }
 533
 534 int UtcDaliFrameCallbackBake(void)
 535 {
 536   // Test to see that the bake methods bake the values
 537
 538   TestApplication application;
 539   Vector2         actorSize(200, 300);
 540
 541   Actor actor = Actor::New();
 542   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
 543   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 544   actor.SetProperty(Actor::Property::SIZE, actorSize);
 545
 546   Stage stage = Stage::GetCurrent();
 547   stage.Add(actor);
 548
 549   Vector3    sizeToSet(1.0f, 2.0f, 3.0f);
 550   Vector3    positionToSet(10.0f, 20.0f, 30.0f);
 551   Vector4    colorToSet(Color::MAGENTA);
 552   Vector3    scaleToSet(1.0f, 3.0f, 5.0f);
 553   Quaternion orientationToSet(Radian(Math::PI * 0.3), Vector3::YAXIS);
 554
 555   FrameCallbackBaker frameCallback(actor.GetProperty<int>(Actor::Property::ID), sizeToSet, positionToSet, colorToSet, scaleToSet, orientationToSet);
 556   DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
 557
 558   application.SendNotification();
 559   application.Render();
 560
 561   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 562   DALI_TEST_EQUALS(frameCallback.mSizeAfterSetting, sizeToSet, TEST_LOCATION);
 563   DALI_TEST_EQUALS(frameCallback.mPositionAfterSetting, positionToSet, TEST_LOCATION);
 564   DALI_TEST_EQUALS(frameCallback.mColorAfterSetting, colorToSet, TEST_LOCATION);
 565   DALI_TEST_EQUALS(frameCallback.mScaleAfterSetting, scaleToSet, TEST_LOCATION);
 566   DALI_TEST_EQUALS(frameCallback.mOrientationAfterSetting, orientationToSet, TEST_LOCATION);
 567
 568   // Ensure the new values are saved after removing the callback
 569   DevelStage::RemoveFrameCallback(stage, frameCallback);
 570
 571   application.SendNotification();
 572   application.Render();
 573
 574   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), positionToSet, TEST_LOCATION);
 575   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>(), sizeToSet, TEST_LOCATION);
 576   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::COLOR).Get<Vector4>(), colorToSet, TEST_LOCATION);
 577   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SCALE).Get<Vector3>(), scaleToSet, TEST_LOCATION);
 578   DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::ORIENTATION).Get<Quaternion>(), orientationToSet, TEST_LOCATION);
 579
 580   END_TEST;
 581 }
 582
 583 int UtcDaliFrameCallbackMultipleActors(void)
 584 {
 585   /**
 586    * Test to check that the frame callback behaves appropriately with multiple actors
 587    *
 588    * Tree:
 589    *              root-layer
 590    *              /        \
 591    *             /          \
 592    *            /            \
 593    *           /              \
 594    *        actorA           actorE
 595    *         / \              / \
 596    *        /   \            /   \
 597    *    actorB  actorD   actorF actorG
 598    *      /                        \
 599    *   actorC                     actorH
 600    *
 601    *  Screen positions (with minor alterations due to local position):
 602    *  -----------------------
 603    *  |actorA|actorD        |
 604    *  |      actorB         |
 605    *  |      actorC         |
 606    *  |                     |
 607    *  |                     |
 608    *  |                     |
 609    *  |                     |
 610    *  |                     |
 611    *  |actorF       actorH  |
 612    *  |actorE|actorG        |
 613    *  -----------------------
 614    */
 615
 616   TestApplication application;
 617   Stage           stage = Stage::GetCurrent();
 618
 619   std::map<char, Vector3> sizes;
 620   sizes['A'] = Vector3(50.0f, 50.0f, 0.0f);
 621   sizes['B'] = Vector3(100.0f, 100.0f, 0.0f);
 622   sizes['C'] = Vector3(150.0f, 150.0f, 0.0f);
 623   sizes['D'] = Vector3(200.0f, 200.0f, 0.0f);
 624   sizes['E'] = Vector3(250.0f, 250.0f, 0.0f);
 625   sizes['F'] = Vector3(300.0f, 300.0f, 0.0f);
 626   sizes['G'] = Vector3(350.0f, 350.0f, 0.0f);
 627   sizes['H'] = Vector3(400.0f, 350.0f, 0.0f);
 628
 629   std::map<char, Vector3> positions;
 630   positions['A'] = Vector3(0.0f, 1.0f, 2.0f);
 631   positions['B'] = Vector3(2.0f, 3.0f, 4.0f);
 632   positions['C'] = Vector3(5.0f, 6.0f, 7.0f);
 633   positions['D'] = Vector3(8.0f, 9.0f, 10.0f);
 634   positions['E'] = Vector3(11.0f, 12.0f, 13.0f);
 635   positions['F'] = Vector3(14.0f, 15.0f, 16.0f);
 636   positions['G'] = Vector3(17.0f, 18.0f, 19.0f);
 637   positions['H'] = Vector3(20.0f, 21.0f, 22.0f);
 638
 639   Actor actorA = Actor::New();
 640   actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
 641   actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 642   actorA.SetProperty(Actor::Property::SIZE, sizes['A']);
 643   actorA.SetProperty(Actor::Property::POSITION, positions['A']);
 644   stage.Add(actorA);
 645
 646   Actor actorB = Actor::New();
 647   actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_RIGHT);
 648   actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 649   actorB.SetProperty(Actor::Property::SIZE, sizes['B']);
 650   actorB.SetProperty(Actor::Property::POSITION, positions['B']);
 651   actorA.Add(actorB);
 652
 653   Actor actorC = Actor::New();
 654   actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_CENTER);
 655   actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER);
 656   actorC.SetProperty(Actor::Property::SIZE, sizes['C']);
 657   actorC.SetProperty(Actor::Property::POSITION, positions['C']);
 658   actorB.Add(actorC);
 659
 660   Actor actorD = Actor::New();
 661   actorD.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_RIGHT);
 662   actorD.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
 663   actorD.SetProperty(Actor::Property::SIZE, sizes['D']);
 664   actorD.SetProperty(Actor::Property::POSITION, positions['D']);
 665   actorA.Add(actorD);
 666
 667   Actor actorE = Actor::New();
 668   actorE.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT);
 669   actorE.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT);
 670   actorE.SetProperty(Actor::Property::SIZE, sizes['E']);
 671   actorE.SetProperty(Actor::Property::POSITION, positions['E']);
 672   stage.Add(actorE);
 673
 674   Actor actorF = Actor::New();
 675   actorF.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER);
 676   actorF.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER);
 677   actorF.SetProperty(Actor::Property::SIZE, sizes['F']);
 678   actorF.SetProperty(Actor::Property::POSITION, positions['F']);
 679   actorE.Add(actorF);
 680
 681   Actor actorG = Actor::New();
 682   actorG.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_RIGHT);
 683   actorG.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
 684   actorG.SetProperty(Actor::Property::SIZE, sizes['G']);
 685   actorG.SetProperty(Actor::Property::POSITION, positions['G']);
 686   actorE.Add(actorG);
 687
 688   Actor actorH = Actor::New();
 689   actorH.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT);
 690   actorH.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT);
 691   actorH.SetProperty(Actor::Property::SIZE, sizes['H']);
 692   actorH.SetProperty(Actor::Property::POSITION, positions['H']);
 693   actorG.Add(actorH);
 694
 695   std::map<char, unsigned int> actorIds;
 696   actorIds['A'] = actorA.GetProperty<int>(Actor::Property::ID);
 697   actorIds['B'] = actorB.GetProperty<int>(Actor::Property::ID);
 698   actorIds['C'] = actorC.GetProperty<int>(Actor::Property::ID);
 699   actorIds['D'] = actorD.GetProperty<int>(Actor::Property::ID);
 700   actorIds['E'] = actorE.GetProperty<int>(Actor::Property::ID);
 701   actorIds['F'] = actorF.GetProperty<int>(Actor::Property::ID);
 702   actorIds['G'] = actorG.GetProperty<int>(Actor::Property::ID);
 703   actorIds['H'] = actorH.GetProperty<int>(Actor::Property::ID);
 704
 705   FrameCallbackMultipleActors frameCallback;
 706   for(auto&& i : actorIds)
 707   {
 708     frameCallback.mActorIds.PushBack(i.second);
 709   }
 710
 711   DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
 712
 713   application.SendNotification();
 714   application.Render();
 715
 716   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 717
 718   for(char i = 'A'; i <= 'H'; ++i)
 719   {
 720     DALI_TEST_EQUALS(frameCallback.mPositions[actorIds[i]], positions[i], TEST_LOCATION);
 721     DALI_TEST_EQUALS(frameCallback.mSizes[actorIds[i]], sizes[i], TEST_LOCATION);
 722   }
 723
 724   // Render again to make sure it still gets called and gives the correct values (in case any optimisations break this)
 725   frameCallback.mCalled = false;
 726
 727   application.SendNotification();
 728   application.Render();
 729
 730   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 731
 732   for(char i = 'A'; i <= 'H'; ++i)
 733   {
 734     DALI_TEST_EQUALS(frameCallback.mPositions[actorIds[i]], positions[i], TEST_LOCATION);
 735     DALI_TEST_EQUALS(frameCallback.mSizes[actorIds[i]], sizes[i], TEST_LOCATION);
 736   }
 737
 738   END_TEST;
 739 }
 740
 741 int UtcDaliFrameCallbackCheckActorNotAdded(void)
 742 {
 743   TestApplication application;
 744
 745   Actor actor = Actor::New();
 746   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
 747   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 748   actor.SetProperty(Actor::Property::SIZE, Vector2(200, 300));
 749
 750   Stage                 stage = Stage::GetCurrent();
 751   FrameCallbackOneActor frameCallback(actor.GetProperty<int>(Actor::Property::ID));
 752   DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
 753
 754   application.SendNotification();
 755   application.Render();
 756
 757   // All should be default constructed objects
 758   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 759   DALI_TEST_EQUALS(frameCallback.mPositionGetPositionCall, Vector3::ZERO, TEST_LOCATION);
 760   DALI_TEST_EQUALS(frameCallback.mWorldPosition, Vector3::ZERO, TEST_LOCATION);
 761   DALI_TEST_EQUALS(frameCallback.mSizeGetSizeCall, Vector3::ZERO, TEST_LOCATION);
 762   DALI_TEST_EQUALS(frameCallback.mColor, Vector4::ZERO, TEST_LOCATION);
 763   DALI_TEST_EQUALS(frameCallback.mScale, Vector3::ZERO, TEST_LOCATION);
 764   DALI_TEST_EQUALS(frameCallback.mWorldScale, Vector3::ZERO, TEST_LOCATION);
 765   DALI_TEST_EQUALS(frameCallback.mOrientation, Quaternion::IDENTITY, TEST_LOCATION);
 766
 767   END_TEST;
 768 }
 769
 770 int UtcDaliFrameCallbackInvalidActorId(void)
 771 {
 772   // Test to ensure that there are no issues when trying to use the update-proxy methods with an invalid actor ID.
 773
 774   TestApplication application;
 775   Stage           stage = Stage::GetCurrent();
 776
 777   FrameCallbackActorIdCheck frameCallback(10000);
 778   DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
 779
 780   application.SendNotification();
 781   application.Render();
 782
 783   // Invalid Actor ID so all the methods should not return successfully.
 784
 785   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 786   DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, false, TEST_LOCATION);
 787   DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, false, TEST_LOCATION);
 788   DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, false, TEST_LOCATION);
 789   DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, false, TEST_LOCATION);
 790   DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, false, TEST_LOCATION);
 791   DALI_TEST_EQUALS(frameCallback.mGetWorldPositionScaleAndSizeCallSuccess, false, TEST_LOCATION);
 792   DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, false, TEST_LOCATION);
 793   DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, false, TEST_LOCATION);
 794   DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, false, TEST_LOCATION);
 795   DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, false, TEST_LOCATION);
 796   DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, false, TEST_LOCATION);
 797   DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, false, TEST_LOCATION);
 798   DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, false, TEST_LOCATION);
 799   DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, false, TEST_LOCATION);
 800
 801   DALI_TEST_EQUALS(frameCallback.mGetOrientationCallSuccess, false, TEST_LOCATION);
 802   DALI_TEST_EQUALS(frameCallback.mSetOrientationCallSuccess, false, TEST_LOCATION);
 803   DALI_TEST_EQUALS(frameCallback.mBakeOrientationCallSuccess, false, TEST_LOCATION);
 804
 805   DALI_TEST_EQUALS(frameCallback.mGetWorldTransformCallSuccess, false, TEST_LOCATION);
 806   DALI_TEST_EQUALS(frameCallback.mGetUpdateAreaCallSuccess, false, TEST_LOCATION);
 807   DALI_TEST_EQUALS(frameCallback.mSetUpdateAreaCallSuccess, false, TEST_LOCATION);
 808
 809   END_TEST;
 810 }
 811
 812 int UtcDaliFrameCallbackActorRemovedAndAdded(void)
 813 {
 814   // Test to ensure that we do not call methods on actors that have been removed on the stage
 815   // and then re-start calling the required methods if that actor is re-added back to the stage
 816
 817   TestApplication application;
 818   Stage           stage = Stage::GetCurrent();
 819
 820   Actor actor = Actor::New();
 821   stage.Add(actor);
 822
 823   FrameCallbackActorIdCheck frameCallback(actor.GetProperty<int>(Actor::Property::ID));
 824   DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
 825
 826   application.SendNotification();
 827   application.Render();
 828
 829   // All methods should return successfully.
 830
 831   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 832   DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, true, TEST_LOCATION);
 833   DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, true, TEST_LOCATION);
 834   DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, true, TEST_LOCATION);
 835   DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, true, TEST_LOCATION);
 836   DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, true, TEST_LOCATION);
 837   DALI_TEST_EQUALS(frameCallback.mGetWorldPositionScaleAndSizeCallSuccess, true, TEST_LOCATION);
 838   DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, true, TEST_LOCATION);
 839   DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, true, TEST_LOCATION);
 840   DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, true, TEST_LOCATION);
 841   DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, true, TEST_LOCATION);
 842   DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, true, TEST_LOCATION);
 843   DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, true, TEST_LOCATION);
 844   DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, true, TEST_LOCATION);
 845   DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, true, TEST_LOCATION);
 846   DALI_TEST_EQUALS(frameCallback.mGetOrientationCallSuccess, true, TEST_LOCATION);
 847   DALI_TEST_EQUALS(frameCallback.mSetOrientationCallSuccess, true, TEST_LOCATION);
 848   DALI_TEST_EQUALS(frameCallback.mBakeOrientationCallSuccess, true, TEST_LOCATION);
 849   DALI_TEST_EQUALS(frameCallback.mGetWorldTransformCallSuccess, true, TEST_LOCATION);
 850   DALI_TEST_EQUALS(frameCallback.mGetUpdateAreaCallSuccess, true, TEST_LOCATION);
 851   DALI_TEST_EQUALS(frameCallback.mSetUpdateAreaCallSuccess, true, TEST_LOCATION);
 852
 853   frameCallback.Reset();
 854
 855   // Remove the actor from stage, the methods should not return successfully.
 856
 857   stage.Remove(actor);
 858
 859   application.SendNotification();
 860   application.Render();
 861
 862   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 863   DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, false, TEST_LOCATION);
 864   DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, false, TEST_LOCATION);
 865   DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, false, TEST_LOCATION);
 866   DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, false, TEST_LOCATION);
 867   DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, false, TEST_LOCATION);
 868   DALI_TEST_EQUALS(frameCallback.mGetWorldPositionScaleAndSizeCallSuccess, false, TEST_LOCATION);
 869   DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, false, TEST_LOCATION);
 870   DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, false, TEST_LOCATION);
 871   DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, false, TEST_LOCATION);
 872   DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, false, TEST_LOCATION);
 873   DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, false, TEST_LOCATION);
 874   DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, false, TEST_LOCATION);
 875   DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, false, TEST_LOCATION);
 876   DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, false, TEST_LOCATION);
 877   DALI_TEST_EQUALS(frameCallback.mGetOrientationCallSuccess, false, TEST_LOCATION);
 878   DALI_TEST_EQUALS(frameCallback.mSetOrientationCallSuccess, false, TEST_LOCATION);
 879   DALI_TEST_EQUALS(frameCallback.mBakeOrientationCallSuccess, false, TEST_LOCATION);
 880   DALI_TEST_EQUALS(frameCallback.mGetWorldTransformCallSuccess, false, TEST_LOCATION);
 881   DALI_TEST_EQUALS(frameCallback.mGetUpdateAreaCallSuccess, false, TEST_LOCATION);
 882   DALI_TEST_EQUALS(frameCallback.mSetUpdateAreaCallSuccess, false, TEST_LOCATION);
 883
 884   frameCallback.Reset();
 885
 886   // Re-add the actor back to the stage, all the methods should once again, return successfully.
 887
 888   stage.Add(actor);
 889
 890   application.SendNotification();
 891   application.Render();
 892
 893   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
 894   DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, true, TEST_LOCATION);
 895   DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, true, TEST_LOCATION);
 896   DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, true, TEST_LOCATION);
 897   DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, true, TEST_LOCATION);
 898   DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, true, TEST_LOCATION);
 899   DALI_TEST_EQUALS(frameCallback.mGetWorldPositionScaleAndSizeCallSuccess, true, TEST_LOCATION);
 900   DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, true, TEST_LOCATION);
 901   DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, true, TEST_LOCATION);
 902   DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, true, TEST_LOCATION);
 903   DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, true, TEST_LOCATION);
 904   DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, true, TEST_LOCATION);
 905   DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, true, TEST_LOCATION);
 906   DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, true, TEST_LOCATION);
 907   DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, true, TEST_LOCATION);
 908   DALI_TEST_EQUALS(frameCallback.mGetOrientationCallSuccess, true, TEST_LOCATION);
 909   DALI_TEST_EQUALS(frameCallback.mSetOrientationCallSuccess, true, TEST_LOCATION);
 910   DALI_TEST_EQUALS(frameCallback.mBakeOrientationCallSuccess, true, TEST_LOCATION);
 911   DALI_TEST_EQUALS(frameCallback.mGetWorldTransformCallSuccess, true, TEST_LOCATION);
 912   DALI_TEST_EQUALS(frameCallback.mGetUpdateAreaCallSuccess, true, TEST_LOCATION);
 913   DALI_TEST_EQUALS(frameCallback.mSetUpdateAreaCallSuccess, true, TEST_LOCATION);
 914
 915   END_TEST;
 916 }
 917
 918 int UtcDaliFrameCallbackMultipleCallbacks(void)
 919 {
 920   // Test to ensure multiple frame-callbacks work as expected
 921
 922   TestApplication application;
 923   Stage           stage = Stage::GetCurrent();
 924
 925   Actor actor = Actor::New();
 926   stage.Add(actor);
 927
 928   FrameCallbackBasic frameCallback1;
 929   FrameCallbackBasic frameCallback2;
 930   DevelStage::AddFrameCallback(stage, frameCallback1, stage.GetRootLayer());
 931   DevelStage::AddFrameCallback(stage, frameCallback2, stage.GetRootLayer());
 932
 933   application.SendNotification();
 934   application.Render();
 935
 936   DALI_TEST_EQUALS(frameCallback1.mCalled, true, TEST_LOCATION);
 937   DALI_TEST_EQUALS(frameCallback2.mCalled, true, TEST_LOCATION);
 938   frameCallback1.Reset();
 939   frameCallback2.Reset();
 940
 941   // Remove the second frame-callback, only the first should be called
 942
 943   DevelStage::RemoveFrameCallback(stage, frameCallback2);
 944
 945   application.SendNotification();
 946   application.Render();
 947
 948   DALI_TEST_EQUALS(frameCallback1.mCalled, true, TEST_LOCATION);
 949   DALI_TEST_EQUALS(frameCallback2.mCalled, false, TEST_LOCATION);
 950   frameCallback1.Reset();
 951   frameCallback2.Reset();
 952
 953   // Re-add the second frame-callback and remove the first, only the second should be called
 954
 955   DevelStage::AddFrameCallback(stage, frameCallback2, stage.GetRootLayer());
 956   DevelStage::RemoveFrameCallback(stage, frameCallback1);
 957
 958   application.SendNotification();
 959   application.Render();
 960
 961   DALI_TEST_EQUALS(frameCallback1.mCalled, false, TEST_LOCATION);
 962   DALI_TEST_EQUALS(frameCallback2.mCalled, true, TEST_LOCATION);
 963   frameCallback1.Reset();
 964   frameCallback2.Reset();
 965
 966   // Attempt removal of the first frame-callback again, should be a no-op and yield the exact same results as the last run
 967   DevelStage::RemoveFrameCallback(stage, frameCallback1);
 968
 969   application.SendNotification();
 970   application.Render();
 971
 972   DALI_TEST_EQUALS(frameCallback1.mCalled, false, TEST_LOCATION);
 973   DALI_TEST_EQUALS(frameCallback2.mCalled, true, TEST_LOCATION);
 974   frameCallback1.Reset();
 975   frameCallback2.Reset();
 976
 977   // Remove the second frame-callback as well, neither should be called
 978   DevelStage::RemoveFrameCallback(stage, frameCallback2);
 979
 980   application.SendNotification();
 981   application.Render();
 982
 983   DALI_TEST_EQUALS(frameCallback1.mCalled, false, TEST_LOCATION);
 984   DALI_TEST_EQUALS(frameCallback2.mCalled, false, TEST_LOCATION);
 985
 986   END_TEST;
 987 }
 988
 989 int UtcDaliFrameCallbackActorDestroyed(void)
 990 {
 991   // Test to ensure that the frame-callback behaves gracefully if the connected root-actor is destroyed
 992
 993   TestApplication application;
 994   Stage           stage = Stage::GetCurrent();
 995
 996   Actor actor = Actor::New();
 997   stage.Add(actor);
 998
 999   FrameCallbackBasic frameCallback1;
1000   FrameCallbackBasic frameCallback2;
1001   DevelStage::AddFrameCallback(stage, frameCallback1, actor);
1002   DevelStage::AddFrameCallback(stage, frameCallback2, actor);
1003
1004   application.SendNotification();
1005   application.Render();
1006
1007   DALI_TEST_EQUALS(frameCallback1.mCalled, true, TEST_LOCATION);
1008   DALI_TEST_EQUALS(frameCallback2.mCalled, true, TEST_LOCATION);
1009   frameCallback1.Reset();
1010   frameCallback2.Reset();
1011
1012   // Remove the second frame-callback, only the first should be called
1013
1014   DevelStage::RemoveFrameCallback(stage, frameCallback2);
1015
1016   application.SendNotification();
1017   application.Render();
1018
1019   DALI_TEST_EQUALS(frameCallback1.mCalled, true, TEST_LOCATION);
1020   DALI_TEST_EQUALS(frameCallback2.mCalled, false, TEST_LOCATION);
1021   frameCallback1.Reset();
1022   frameCallback2.Reset();
1023
1024   // Remove and destroy the actor, the first one should not be called either
1025   stage.Remove(actor);
1026   actor.Reset();
1027
1028   application.SendNotification();
1029   application.Render();
1030
1031   DALI_TEST_EQUALS(frameCallback1.mCalled, false, TEST_LOCATION);
1032   DALI_TEST_EQUALS(frameCallback2.mCalled, false, TEST_LOCATION);
1033
1034   END_TEST;
1035 }
1036
1037 int UtcDaliFrameCallbackDestroyedBeforeRemoving(void)
1038 {
1039   // Ensure there's no segmentation fault if the callback is deleted without being removed
1040
1041   TestApplication application;
1042   Stage           stage = Stage::GetCurrent();
1043
1044   Actor actor = Actor::New();
1045   stage.Add(actor);
1046
1047   {
1048     FrameCallbackBasic frameCallback;
1049     DevelStage::AddFrameCallback(stage, frameCallback, actor);
1050
1051     application.SendNotification();
1052     application.Render();
1053
1054     DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
1055     frameCallback.Reset();
1056   }
1057
1058   // frameCallback has now been destroyed but not removed
1059
1060   application.SendNotification();
1061   application.Render();
1062   DALI_TEST_CHECK(true); // If it runs to here then there's no segmentation fault
1063
1064   END_TEST;
1065 }
1066
1067 int UtcDaliFrameCallbackDoubleAddition(void)
1068 {
1069   // Ensure we don't connect the same frame-callback twice
1070
1071   TestApplication application;
1072   Stage           stage     = Stage::GetCurrent();
1073   Actor           rootActor = stage.GetRootLayer();
1074
1075   FrameCallbackBasic frameCallback;
1076   DevelStage::AddFrameCallback(stage, frameCallback, rootActor);
1077
1078   try
1079   {
1080     DevelStage::AddFrameCallback(stage, frameCallback, rootActor);
1081   }
1082   catch(...)
1083   {
1084     DALI_TEST_CHECK(true);
1085   }
1086
1087   END_TEST;
1088 }
1089
1090 int UtcDaliFrameCallbackUpdateStatus(void)
1091 {
1092   // Ensure the update status is consistent with whether the framecallback requests to keep rendering or not
1093
1094   TestApplication application;
1095   Stage           stage = Stage::GetCurrent();
1096
1097   Actor actor = Actor::New();
1098   stage.Add(actor);
1099
1100   application.SendNotification();
1101   application.Render();
1102
1103   DALI_TEST_EQUALS(application.GetUpdateStatus(), 0, TEST_LOCATION);
1104
1105   // This framecallback doesn't request to keep rendering
1106   FrameCallbackMultipleActors frameCallbackMultipleActors;
1107   DevelStage::AddFrameCallback(stage, frameCallbackMultipleActors, actor);
1108
1109   application.SendNotification();
1110   application.Render();
1111
1112   DALI_TEST_EQUALS(application.GetUpdateStatus(), 0, TEST_LOCATION);
1113
1114   // This framecallback requests to keep rendering
1115   FrameCallbackBasic frameCallbackBasic;
1116   DevelStage::AddFrameCallback(stage, frameCallbackBasic, actor);
1117
1118   application.SendNotification();
1119   application.Render();
1120
1121   DALI_TEST_EQUALS(application.GetUpdateStatus(), Integration::KeepUpdating::FRAME_UPDATE_CALLBACK, TEST_LOCATION);
1122
1123   END_TEST;
1124 }
1125
1126 int UtcDaliFrameCallbackGetExtension(void)
1127 {
1128   FrameCallbackBasic frameCallback;
1129   DALI_TEST_CHECK(frameCallback.GetExtension() == nullptr);
1130
1131   END_TEST;
1132 }
1133
1134 int UtcDaliFrameCallbackUpdateNotify01(void)
1135 {
1136   tet_infoline("Test that the frame callback can be notified");
1137
1138   TestApplication application;
1139   Vector2         actorSize(200, 300);
1140
1141   Actor actor = Actor::New();
1142   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1143   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1144   actor.SetProperty(Actor::Property::SIZE, actorSize);
1145
1146   Stage stage = Stage::GetCurrent();
1147   stage.Add(actor);
1148
1149   Vector3    sizeToSet(1.0f, 2.0f, 3.0f);
1150   Vector3    positionToSet(10.0f, 20.0f, 30.0f);
1151   Vector4    colorToSet(Color::MAGENTA);
1152   Vector3    scaleToSet(1.0f, 3.0f, 5.0f);
1153   Quaternion orientationToSet(Radian(Math::PI * 0.3), Vector3::YAXIS);
1154
1155   tet_infoline("Test that the frame callback was called without a notify");
1156   FrameCallbackNotify frameCallback;
1157   DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
1158   Stage::GetCurrent().KeepRendering(30);
1159   application.SendNotification();
1160   application.Render(16);
1161
1162   DALI_TEST_CHECK(!frameCallback.mTriggered);
1163   DALI_TEST_CHECK(frameCallback.mSyncPoints.empty());
1164
1165   tet_infoline("Test that the frame callback was called with a notify");
1166   UpdateProxy::NotifySyncPoint syncPoint = DevelStage::NotifyFrameCallback(stage, frameCallback);
1167   DALI_TEST_CHECK(syncPoint != UpdateProxy::INVALID_SYNC);
1168   frameCallback.SetSyncTrigger(syncPoint);
1169
1170   application.SendNotification();
1171   application.Render(16);
1172   DALI_TEST_CHECK(frameCallback.mTriggered);
1173   DALI_TEST_CHECK(!frameCallback.mSyncPoints.empty());
1174
1175   tet_infoline("Test that the frame callback was called without a notify");
1176
1177   frameCallback.SetSyncTrigger(UpdateProxy::INVALID_SYNC);
1178   frameCallback.mSyncPoints.clear();
1179   frameCallback.mTriggered = false;
1180
1181   application.SendNotification();
1182   application.Render(16);
1183   DALI_TEST_CHECK(!frameCallback.mTriggered);
1184   DALI_TEST_CHECK(frameCallback.mSyncPoints.empty());
1185
1186   tet_infoline("Test that adding 2 notify before next update contains both");
1187
1188   auto syncPoint1 = DevelStage::NotifyFrameCallback(stage, frameCallback);
1189   DALI_TEST_CHECK(syncPoint1 != UpdateProxy::INVALID_SYNC);
1190   auto syncPoint2 = DevelStage::NotifyFrameCallback(stage, frameCallback);
1191   DALI_TEST_CHECK(syncPoint2 != UpdateProxy::INVALID_SYNC);
1192   DALI_TEST_CHECK(syncPoint1 != syncPoint2);
1193   application.SendNotification();
1194   application.Render(16);
1195
1196   DALI_TEST_EQUALS(frameCallback.mSyncPoints.size(), 2, TEST_LOCATION);
1197   DALI_TEST_EQUALS(frameCallback.mSyncPoints.front(), syncPoint1, TEST_LOCATION);
1198   DALI_TEST_EQUALS(frameCallback.mSyncPoints.back(), syncPoint2, TEST_LOCATION);
1199   END_TEST;
1200 }
1201
1202 int UtcDaliFrameCallbackWithoutRootActor(void)
1203 {
1204   // Test to ensure that we should call methods on actors even if have been removed on the stage
1205   // If we add frame callback with empty handle.
1206
1207   TestApplication application;
1208   Stage           stage = Stage::GetCurrent();
1209
1210   Actor actor = Actor::New();
1211   stage.Add(actor);
1212
1213   FrameCallbackActorIdCheck frameCallback(actor.GetProperty<int>(Actor::Property::ID));
1214   DevelStage::AddFrameCallback(stage, frameCallback, Actor());
1215
1216   application.SendNotification();
1217   application.Render();
1218
1219   // All methods should return successfully.
1220
1221   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
1222   DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, true, TEST_LOCATION);
1223   DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, true, TEST_LOCATION);
1224   DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, true, TEST_LOCATION);
1225   DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, true, TEST_LOCATION);
1226   DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, true, TEST_LOCATION);
1227   DALI_TEST_EQUALS(frameCallback.mGetWorldPositionScaleAndSizeCallSuccess, true, TEST_LOCATION);
1228   DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, true, TEST_LOCATION);
1229   DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, true, TEST_LOCATION);
1230   DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, true, TEST_LOCATION);
1231   DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, true, TEST_LOCATION);
1232   DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, true, TEST_LOCATION);
1233   DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, true, TEST_LOCATION);
1234   DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, true, TEST_LOCATION);
1235   DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, true, TEST_LOCATION);
1236   DALI_TEST_EQUALS(frameCallback.mGetOrientationCallSuccess, true, TEST_LOCATION);
1237   DALI_TEST_EQUALS(frameCallback.mSetOrientationCallSuccess, true, TEST_LOCATION);
1238   DALI_TEST_EQUALS(frameCallback.mBakeOrientationCallSuccess, true, TEST_LOCATION);
1239   DALI_TEST_EQUALS(frameCallback.mGetWorldTransformCallSuccess, true, TEST_LOCATION);
1240   DALI_TEST_EQUALS(frameCallback.mGetUpdateAreaCallSuccess, true, TEST_LOCATION);
1241   DALI_TEST_EQUALS(frameCallback.mSetUpdateAreaCallSuccess, true, TEST_LOCATION);
1242
1243   frameCallback.Reset();
1244
1245   // Remove the actor from stage, the methods should return successfully.
1246
1247   stage.Remove(actor);
1248
1249   application.SendNotification();
1250   application.Render();
1251
1252   DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
1253   DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, true, TEST_LOCATION);
1254   DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, true, TEST_LOCATION);
1255   DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, true, TEST_LOCATION);
1256   DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, true, TEST_LOCATION);
1257   DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, true, TEST_LOCATION);
1258   DALI_TEST_EQUALS(frameCallback.mGetWorldPositionScaleAndSizeCallSuccess, true, TEST_LOCATION);
1259   DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, true, TEST_LOCATION);
1260   DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, true, TEST_LOCATION);
1261   DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, true, TEST_LOCATION);
1262   DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, true, TEST_LOCATION);
1263   DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, true, TEST_LOCATION);
1264   DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, true, TEST_LOCATION);
1265   DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, true, TEST_LOCATION);
1266   DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, true, TEST_LOCATION);
1267   DALI_TEST_EQUALS(frameCallback.mGetOrientationCallSuccess, true, TEST_LOCATION);
1268   DALI_TEST_EQUALS(frameCallback.mSetOrientationCallSuccess, true, TEST_LOCATION);
1269   DALI_TEST_EQUALS(frameCallback.mBakeOrientationCallSuccess, true, TEST_LOCATION);
1270   DALI_TEST_EQUALS(frameCallback.mGetWorldTransformCallSuccess, true, TEST_LOCATION);
1271   DALI_TEST_EQUALS(frameCallback.mGetUpdateAreaCallSuccess, true, TEST_LOCATION);
1272   DALI_TEST_EQUALS(frameCallback.mSetUpdateAreaCallSuccess, true, TEST_LOCATION);
1273
1274   // Remove callback. frameCallback should not be called.
1275
1276   frameCallback.Reset();
1277   DevelStage::RemoveFrameCallback(stage, frameCallback);
1278
1279   application.SendNotification();
1280   application.Render();
1281
1282   DALI_TEST_EQUALS(frameCallback.mCalled, false, TEST_LOCATION);
1283   DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, false, TEST_LOCATION);
1284   DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, false, TEST_LOCATION);
1285   DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, false, TEST_LOCATION);
1286   DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, false, TEST_LOCATION);
1287   DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, false, TEST_LOCATION);
1288   DALI_TEST_EQUALS(frameCallback.mGetWorldPositionScaleAndSizeCallSuccess, false, TEST_LOCATION);
1289   DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, false, TEST_LOCATION);
1290   DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, false, TEST_LOCATION);
1291   DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, false, TEST_LOCATION);
1292   DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, false, TEST_LOCATION);
1293   DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, false, TEST_LOCATION);
1294   DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, false, TEST_LOCATION);
1295   DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, false, TEST_LOCATION);
1296   DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, false, TEST_LOCATION);
1297   DALI_TEST_EQUALS(frameCallback.mGetOrientationCallSuccess, false, TEST_LOCATION);
1298   DALI_TEST_EQUALS(frameCallback.mSetOrientationCallSuccess, false, TEST_LOCATION);
1299   DALI_TEST_EQUALS(frameCallback.mBakeOrientationCallSuccess, false, TEST_LOCATION);
1300   DALI_TEST_EQUALS(frameCallback.mGetWorldTransformCallSuccess, false, TEST_LOCATION);
1301   DALI_TEST_EQUALS(frameCallback.mGetUpdateAreaCallSuccess, false, TEST_LOCATION);
1302   DALI_TEST_EQUALS(frameCallback.mSetUpdateAreaCallSuccess, false, TEST_LOCATION);
1303
1304   frameCallback.Reset();
1305
1306   // Re-add the actor back to the stage, but frameCallback should not be emitted because we remove it.
1307
1308   stage.Add(actor);
1309
1310   application.SendNotification();
1311   application.Render();
1312
1313   DALI_TEST_EQUALS(frameCallback.mCalled, false, TEST_LOCATION);
1314   DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, false, TEST_LOCATION);
1315   DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, false, TEST_LOCATION);
1316   DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, false, TEST_LOCATION);
1317   DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, false, TEST_LOCATION);
1318   DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, false, TEST_LOCATION);
1319   DALI_TEST_EQUALS(frameCallback.mGetWorldPositionScaleAndSizeCallSuccess, false, TEST_LOCATION);
1320   DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, false, TEST_LOCATION);
1321   DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, false, TEST_LOCATION);
1322   DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, false, TEST_LOCATION);
1323   DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, false, TEST_LOCATION);
1324   DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, false, TEST_LOCATION);
1325   DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, false, TEST_LOCATION);
1326   DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, false, TEST_LOCATION);
1327   DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, false, TEST_LOCATION);
1328   DALI_TEST_EQUALS(frameCallback.mGetOrientationCallSuccess, false, TEST_LOCATION);
1329   DALI_TEST_EQUALS(frameCallback.mSetOrientationCallSuccess, false, TEST_LOCATION);
1330   DALI_TEST_EQUALS(frameCallback.mBakeOrientationCallSuccess, false, TEST_LOCATION);
1331   DALI_TEST_EQUALS(frameCallback.mGetWorldTransformCallSuccess, false, TEST_LOCATION);
1332   DALI_TEST_EQUALS(frameCallback.mGetUpdateAreaCallSuccess, false, TEST_LOCATION);
1333   DALI_TEST_EQUALS(frameCallback.mSetUpdateAreaCallSuccess, false, TEST_LOCATION);
1334
1335   END_TEST;
1336 }