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

   1 /*
   2  * Copyright (c) 2021 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/common/stage.h>
  20 #include <dali/integration-api/events/key-event-integ.h>
  21 #include <dali/integration-api/events/touch-event-integ.h>
  22 #include <dali/integration-api/events/wheel-event-integ.h>
  23 #include <dali/integration-api/scene.h>
  24 #include <dali/public-api/events/key-event.h>
  25 #include <mesh-builder.h>
  26 #include <stdlib.h>
  27
  28 #include <iostream>
  29
  30 // Internal headers are allowed here
  31
  32 namespace
  33 {
  34 const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
  35
  36 // Functor for EventProcessingFinished signal
  37 struct EventProcessingFinishedFunctor
  38 {
  39   /**
  40    * @param[in] eventProcessingFinished reference to a boolean variable used to check if signal has been called.
  41    */
  42   EventProcessingFinishedFunctor(bool& eventProcessingFinished)
  43   : mEventProcessingFinished(eventProcessingFinished)
  44   {
  45   }
  46
  47   void operator()()
  48   {
  49     mEventProcessingFinished = true;
  50   }
  51
  52   bool& mEventProcessingFinished;
  53 };
  54
  55 // Stores data that is populated in the key-event callback and will be read by the TET cases
  56 struct KeyEventSignalData
  57 {
  58   KeyEventSignalData()
  59   : functorCalled(false)
  60   {
  61   }
  62
  63   void Reset()
  64   {
  65     functorCalled = false;
  66
  67     receivedKeyEvent.Reset();
  68   }
  69
  70   bool     functorCalled;
  71   KeyEvent receivedKeyEvent;
  72 };
  73
  74 // Functor that sets the data when called
  75 struct KeyEventReceivedFunctor
  76 {
  77   KeyEventReceivedFunctor(KeyEventSignalData& data)
  78   : signalData(data)
  79   {
  80   }
  81
  82   bool operator()(const KeyEvent& keyEvent)
  83   {
  84     signalData.functorCalled    = true;
  85     signalData.receivedKeyEvent = keyEvent;
  86
  87     return true;
  88   }
  89
  90   KeyEventSignalData& signalData;
  91 };
  92
  93 // Stores data that is populated in the touched signal callback and will be read by the TET cases
  94 struct TouchedSignalData
  95 {
  96   TouchedSignalData()
  97   : functorCalled(false),
  98     createNewScene(false),
  99     newSceneCreated(false)
 100   {
 101   }
 102
 103   void Reset()
 104   {
 105     functorCalled   = false;
 106     createNewScene  = false;
 107     newSceneCreated = false;
 108     receivedTouchEvent.Reset();
 109   }
 110
 111   bool       functorCalled;
 112   bool       createNewScene;
 113   bool       newSceneCreated;
 114   TouchEvent receivedTouchEvent;
 115 };
 116
 117 // Functor that sets the data when touched signal is received
 118 struct TouchFunctor
 119 {
 120   TouchFunctor(TouchedSignalData& data)
 121   : signalData(data)
 122   {
 123   }
 124
 125   void operator()(const TouchEvent& touch)
 126   {
 127     signalData.functorCalled      = true;
 128     signalData.receivedTouchEvent = touch;
 129
 130     if(signalData.createNewScene)
 131     {
 132       Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
 133       DALI_TEST_CHECK(scene);
 134
 135       signalData.newSceneCreated = true;
 136     }
 137   }
 138
 139   void operator()()
 140   {
 141     signalData.functorCalled = true;
 142   }
 143
 144   TouchedSignalData& signalData;
 145 };
 146
 147 // Stores data that is populated in the wheel-event callback and will be read by the TET cases
 148 struct WheelEventSignalData
 149 {
 150   WheelEventSignalData()
 151   : functorCalled(false)
 152   {
 153   }
 154
 155   void Reset()
 156   {
 157     functorCalled = false;
 158   }
 159
 160   bool       functorCalled;
 161   WheelEvent receivedWheelEvent;
 162 };
 163
 164 // Functor that sets the data when wheel-event signal is received
 165 struct WheelEventReceivedFunctor
 166 {
 167   WheelEventReceivedFunctor(WheelEventSignalData& data)
 168   : signalData(data)
 169   {
 170   }
 171
 172   bool operator()(const WheelEvent& wheelEvent)
 173   {
 174     signalData.functorCalled      = true;
 175     signalData.receivedWheelEvent = wheelEvent;
 176
 177     return true;
 178   }
 179
 180   WheelEventSignalData& signalData;
 181 };
 182
 183 // Stores data that is populated in the KeyEventGeneratedSignal callback and will be read by the TET cases
 184 struct KeyEventGeneratedSignalData
 185 {
 186   KeyEventGeneratedSignalData()
 187   : functorCalled(false)
 188   {
 189   }
 190
 191   void Reset()
 192   {
 193     functorCalled = false;
 194
 195     receivedKeyEvent.Reset();
 196   }
 197
 198   bool     functorCalled;
 199   KeyEvent receivedKeyEvent;
 200 };
 201
 202 // Functor that sets the data when called
 203 struct KeyEventGeneratedReceivedFunctor
 204 {
 205   KeyEventGeneratedReceivedFunctor(KeyEventGeneratedSignalData& data)
 206   : signalData(data)
 207   {
 208   }
 209
 210   bool operator()(const KeyEvent& keyEvent)
 211   {
 212     signalData.functorCalled    = true;
 213     signalData.receivedKeyEvent = keyEvent;
 214
 215     return true;
 216   }
 217
 218   bool operator()()
 219   {
 220     signalData.functorCalled = true;
 221     return true;
 222   }
 223
 224   KeyEventGeneratedSignalData& signalData;
 225 };
 226
 227 void GenerateTouch(TestApplication& application, PointState::Type state, const Vector2& screenPosition)
 228 {
 229   Integration::TouchEvent touchEvent;
 230   Integration::Point      point;
 231   point.SetState(state);
 232   point.SetScreenPosition(screenPosition);
 233   touchEvent.points.push_back(point);
 234   application.ProcessEvent(touchEvent);
 235 }
 236
 237 bool DummyTouchCallback(Actor actor, const TouchEvent& touch)
 238 {
 239   return true;
 240 }
 241
 242 void FrameCallback(int frameId)
 243 {
 244 }
 245
 246 } // unnamed namespace
 247
 248 int UtcDaliSceneAdd(void)
 249 {
 250   TestApplication application;
 251   tet_infoline("Testing Dali::Integration::Scene::Add");
 252
 253   Dali::Integration::Scene scene = application.GetScene();
 254
 255   Actor actor = Actor::New();
 256   DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 257
 258   scene.Add(actor);
 259   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 260
 261   END_TEST;
 262 }
 263
 264 int UtcDaliSceneRemove(void)
 265 {
 266   TestApplication application;
 267   tet_infoline("Testing Dali::Integration::Scene::Remove");
 268
 269   Dali::Integration::Scene scene = application.GetScene();
 270
 271   Actor actor = Actor::New();
 272   DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 273
 274   scene.Add(actor);
 275   DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 276
 277   scene.Remove(actor);
 278   DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
 279
 280   END_TEST;
 281 }
 282
 283 int UtcDaliSceneGetSize(void)
 284 {
 285   TestApplication application;
 286   tet_infoline("Testing Dali::Integration::Scene::GetSize");
 287
 288   Dali::Integration::Scene scene = application.GetScene();
 289   Size                     size  = scene.GetSize();
 290   DALI_TEST_EQUALS(TestApplication::DEFAULT_SURFACE_WIDTH, size.width, TEST_LOCATION);
 291   DALI_TEST_EQUALS(TestApplication::DEFAULT_SURFACE_HEIGHT, size.height, TEST_LOCATION);
 292
 293   END_TEST;
 294 }
 295
 296 int UtcDaliSceneGetDpi(void)
 297 {
 298   TestApplication application; // Initializes core DPI to default values
 299
 300   // Test that setting core DPI explicitly also sets up the scene's DPI.
 301   Dali::Integration::Scene scene = application.GetScene();
 302   scene.SetDpi(Vector2(200.0f, 180.0f));
 303   Vector2 dpi = scene.GetDpi();
 304   DALI_TEST_EQUALS(dpi.x, 200.0f, TEST_LOCATION);
 305   DALI_TEST_EQUALS(dpi.y, 180.0f, TEST_LOCATION);
 306   END_TEST;
 307 }
 308
 309 int UtcDaliSceneGetRenderTaskList(void)
 310 {
 311   TestApplication application;
 312   tet_infoline("Testing Dali::Integration::Scene::GetRenderTaskList");
 313
 314   Dali::Integration::Scene scene = application.GetScene();
 315
 316   // Check we get a valid instance.
 317   const RenderTaskList& tasks = scene.GetRenderTaskList();
 318
 319   // There should be 1 task by default.
 320   DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION);
 321
 322   // RenderTaskList has it's own UTC tests.
 323   // But we can confirm that GetRenderTaskList in Stage retrieves the same RenderTaskList each time.
 324   RenderTask newTask = scene.GetRenderTaskList().CreateTask();
 325
 326   DALI_TEST_EQUALS(scene.GetRenderTaskList().GetTask(1), newTask, TEST_LOCATION);
 327
 328   END_TEST;
 329 }
 330
 331 int UtcDaliSceneGetRootLayer(void)
 332 {
 333   TestApplication application;
 334   tet_infoline("Testing Dali::Integration::Scene::GetRootLayer");
 335
 336   Dali::Integration::Scene scene = application.GetScene();
 337   Layer                    layer = scene.GetLayer(0);
 338   DALI_TEST_CHECK(layer);
 339
 340   // Check that GetRootLayer() correctly retreived layer 0.
 341   DALI_TEST_CHECK(scene.GetRootLayer() == layer);
 342
 343   END_TEST;
 344 }
 345
 346 int UtcDaliSceneGetLayerCount(void)
 347 {
 348   TestApplication application;
 349   tet_infoline("Testing Dali::Integration::Scene::GetLayerCount");
 350
 351   Dali::Integration::Scene scene = application.GetScene();
 352   // Initially we have a default layer
 353   DALI_TEST_EQUALS(scene.GetLayerCount(), 1u, TEST_LOCATION);
 354
 355   Layer layer = Layer::New();
 356   scene.Add(layer);
 357
 358   DALI_TEST_EQUALS(scene.GetLayerCount(), 2u, TEST_LOCATION);
 359   END_TEST;
 360 }
 361
 362 int UtcDaliSceneGetLayer(void)
 363 {
 364   TestApplication application;
 365   tet_infoline("Testing Dali::Integration::Scene::GetLayer");
 366
 367   Dali::Integration::Scene scene = application.GetScene();
 368
 369   Layer rootLayer = scene.GetLayer(0);
 370   DALI_TEST_CHECK(rootLayer);
 371
 372   Layer layer = Layer::New();
 373   scene.Add(layer);
 374
 375   Layer sameLayer = scene.GetLayer(1);
 376   DALI_TEST_CHECK(layer == sameLayer);
 377
 378   END_TEST;
 379 }
 380
 381 int UtcDaliSceneGet(void)
 382 {
 383   TestApplication application;
 384   tet_infoline("Testing Dali::Integration::Scene::Get");
 385
 386   Dali::Integration::Scene scene = application.GetScene();
 387
 388   Actor actor = Actor::New();
 389   DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(actor));
 390
 391   scene.Add(actor);
 392
 393   DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(actor));
 394
 395   END_TEST;
 396 }
 397
 398 int UtcDaliSceneDiscard(void)
 399 {
 400   TestApplication application;
 401   tet_infoline("Testing Dali::Scene::Discard");
 402
 403   // Create a new Scene
 404   Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
 405   DALI_TEST_CHECK(scene);
 406
 407   // One reference of scene kept here and the other one kept in the Core
 408   DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 2);
 409
 410   // Render and notify.
 411   application.SendNotification();
 412   application.Render(0);
 413
 414   // Keep the reference of the root layer handle so it will still be alive after the scene is deleted
 415   Layer rootLayer = scene.GetRootLayer();
 416   DALI_TEST_CHECK(rootLayer);
 417   DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 2);
 418
 419   // Request to discard the scene from the Core
 420   scene.Discard();
 421   DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 1);
 422
 423   // Reset the scene handle
 424   scene.Reset();
 425
 426   // Render and notify.
 427   application.SendNotification();
 428   application.Render(0);
 429
 430   // At this point, the scene should have been automatically deleted
 431   // To prove this, the ref count of the root layer handle should be decremented to 1
 432   DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
 433
 434   // Delete the root layer handle
 435   rootLayer.Reset();
 436
 437   // Render and notify.
 438   application.SendNotification();
 439   application.Render(0);
 440
 441   END_TEST;
 442 }
 443
 444 int UtcDaliSceneCreateNewSceneDuringCoreEventProcessing(void)
 445 {
 446   TestApplication application;
 447
 448   Dali::Integration::Scene scene = application.GetScene();
 449
 450   TouchedSignalData data;
 451   data.createNewScene = true;
 452   TouchFunctor functor(data);
 453   scene.TouchedSignal().Connect(&application, functor);
 454
 455   // Render and notify.
 456   application.SendNotification();
 457   application.Render();
 458
 459   GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
 460
 461   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 462   DALI_TEST_EQUALS(true, data.createNewScene, TEST_LOCATION);
 463   DALI_TEST_EQUALS(true, data.newSceneCreated, TEST_LOCATION);
 464   data.Reset();
 465
 466   END_TEST;
 467 }
 468
 469 int UtcDaliSceneRootLayerAndSceneAlignment(void)
 470 {
 471   TestApplication application;
 472
 473   // Create a Scene
 474   Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
 475   DALI_TEST_CHECK(scene);
 476
 477   // One reference of scene kept here and the other one kept in the Core
 478   DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 2);
 479
 480   // Add a renderable actor to the scene
 481   auto actor = CreateRenderableActor();
 482   scene.Add(actor);
 483
 484   // Render and notify.
 485   application.SendNotification();
 486   application.Render(0);
 487
 488   // Keep the reference of the root layer handle so it will still be alive after the scene is deleted
 489   Layer rootLayer = scene.GetRootLayer();
 490   DALI_TEST_CHECK(rootLayer);
 491   DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 2);
 492
 493   // Request to discard the scene from the Core
 494   scene.Discard();
 495   DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 1);
 496
 497   // Reset the scene handle
 498   scene.Reset();
 499
 500   // Render and notify.
 501   application.SendNotification();
 502   application.Render(0);
 503
 504   // At this point, the scene should have been automatically deleted
 505   // To prove this, the ref count of the root layer handle should be decremented to 1
 506   DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
 507
 508   // Create a new Scene while the root layer of the deleted scene is still alive
 509   Dali::Integration::Scene newScene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
 510   DALI_TEST_CHECK(newScene);
 511
 512   // Render and notify.
 513   application.SendNotification();
 514   application.Render(0);
 515
 516   // At this point, we have only one scene but two root layers
 517   // The root layer of the deleted scene is still alive
 518   DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
 519
 520   // Delete the root layer of the deleted scene
 521   rootLayer.Reset();
 522
 523   // Render and notify.
 524   application.SendNotification();
 525   application.Render(0);
 526
 527   END_TEST;
 528 }
 529
 530 int UtcDaliSceneEventProcessingFinishedP(void)
 531 {
 532   TestApplication          application;
 533   Dali::Integration::Scene scene = application.GetScene();
 534
 535   bool                           eventProcessingFinished = false;
 536   EventProcessingFinishedFunctor functor(eventProcessingFinished);
 537   scene.EventProcessingFinishedSignal().Connect(&application, functor);
 538
 539   Actor actor(Actor::New());
 540   scene.Add(actor);
 541
 542   application.SendNotification();
 543   application.Render();
 544
 545   DALI_TEST_CHECK(eventProcessingFinished);
 546
 547   END_TEST;
 548 }
 549
 550 int UtcDaliSceneEventProcessingFinishedN(void)
 551 {
 552   TestApplication          application;
 553   Dali::Integration::Scene scene = application.GetScene();
 554
 555   bool                           eventProcessingFinished = false;
 556   EventProcessingFinishedFunctor functor(eventProcessingFinished);
 557   scene.EventProcessingFinishedSignal().Connect(&application, functor);
 558
 559   Actor actor(Actor::New());
 560   scene.Add(actor);
 561
 562   // Do not complete event processing and confirm the signal has not been emitted.
 563   DALI_TEST_CHECK(!eventProcessingFinished);
 564
 565   END_TEST;
 566 }
 567
 568 int UtcDaliSceneSignalKeyEventP(void)
 569 {
 570   TestApplication          application;
 571   Dali::Integration::Scene scene = application.GetScene();
 572
 573   KeyEventSignalData      data;
 574   KeyEventReceivedFunctor functor(data);
 575   scene.KeyEventSignal().Connect(&application, functor);
 576
 577   Integration::KeyEvent event("i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 578   application.ProcessEvent(event);
 579
 580   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 581   DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
 582   DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
 583   DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
 584   DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
 585
 586   data.Reset();
 587
 588   Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 589   application.ProcessEvent(event2);
 590
 591   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 592   DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
 593   DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
 594   DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
 595   DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
 596
 597   data.Reset();
 598
 599   Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 600   application.ProcessEvent(event3);
 601
 602   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 603   DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
 604   DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
 605   DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
 606   DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
 607
 608   data.Reset();
 609
 610   Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
 611   application.ProcessEvent(event4);
 612
 613   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 614   DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
 615   DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
 616   DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
 617   DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
 618   END_TEST;
 619 }
 620
 621 int UtcDaliSceneSignalKeyEventN(void)
 622 {
 623   TestApplication          application;
 624   Dali::Integration::Scene scene = application.GetScene();
 625
 626   KeyEventSignalData      data;
 627   KeyEventReceivedFunctor functor(data);
 628   scene.KeyEventSignal().Connect(&application, functor);
 629
 630   // Check that a non-pressed key events data is not modified.
 631   DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 632
 633   END_TEST;
 634 }
 635
 636 int UtcDaliSceneTouchedSignalP(void)
 637 {
 638   TestApplication          application;
 639   Dali::Integration::Scene scene = application.GetScene();
 640
 641   TouchedSignalData data;
 642   TouchFunctor      functor(data);
 643   scene.TouchedSignal().Connect(&application, functor);
 644
 645   // Render and notify.
 646   application.SendNotification();
 647   application.Render();
 648
 649   // Basic test: No actors, single touch (down then up).
 650   {
 651     GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
 652
 653     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 654     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 655     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 656     data.Reset();
 657
 658     GenerateTouch(application, PointState::UP, Vector2(10.0f, 10.0f));
 659
 660     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 661     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 662     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 663     data.Reset();
 664   }
 665
 666   // Add an actor to the scene.
 667   Actor actor = Actor::New();
 668   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
 669   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 670   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
 671   actor.TouchedSignal().Connect(&DummyTouchCallback);
 672   scene.Add(actor);
 673
 674   // Render and notify.
 675   application.SendNotification();
 676   application.Render();
 677
 678   // Actor on scene, single touch, down in actor, motion, then up outside actor.
 679   {
 680     GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
 681
 682     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 683     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 684     DALI_TEST_CHECK(data.receivedTouchEvent.GetHitActor(0) == actor);
 685     data.Reset();
 686
 687     GenerateTouch(application, PointState::MOTION, Vector2(150.0f, 10.0f)); // Some motion
 688
 689     DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 690     data.Reset();
 691
 692     GenerateTouch(application, PointState::UP, Vector2(150.0f, 10.0f)); // Some motion
 693
 694     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 695     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 696     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 697     data.Reset();
 698   }
 699
 700   // Multiple touch. Should only receive a touch on first down and last up.
 701   {
 702     Integration::TouchEvent touchEvent;
 703     Integration::Point      point;
 704
 705     // 1st point
 706     point.SetState(PointState::DOWN);
 707     point.SetScreenPosition(Vector2(10.0f, 10.0f));
 708     touchEvent.points.push_back(point);
 709     application.ProcessEvent(touchEvent);
 710     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 711     DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
 712     data.Reset();
 713
 714     // 2nd point
 715     touchEvent.points[0].SetState(PointState::STATIONARY);
 716     point.SetDeviceId(1);
 717     point.SetScreenPosition(Vector2(50.0f, 50.0f));
 718     touchEvent.points.push_back(point);
 719     application.ProcessEvent(touchEvent);
 720     DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 721     data.Reset();
 722
 723     // Primary point is up
 724     touchEvent.points[0].SetState(PointState::UP);
 725     touchEvent.points[1].SetState(PointState::STATIONARY);
 726     application.ProcessEvent(touchEvent);
 727     DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 728     data.Reset();
 729
 730     // Remove 1st point now, 2nd point is now in motion
 731     touchEvent.points.erase(touchEvent.points.begin());
 732     touchEvent.points[0].SetState(PointState::MOTION);
 733     touchEvent.points[0].SetScreenPosition(Vector2(150.0f, 50.0f));
 734     application.ProcessEvent(touchEvent);
 735     DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 736     data.Reset();
 737
 738     // Final point Up
 739     touchEvent.points[0].SetState(PointState::UP);
 740     application.ProcessEvent(touchEvent);
 741     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 742     DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
 743     data.Reset();
 744   }
 745   END_TEST;
 746 }
 747
 748 int UtcDaliSceneTouchedSignalN(void)
 749 {
 750   TestApplication          application;
 751   Dali::Integration::Scene scene = application.GetScene();
 752
 753   TouchedSignalData data;
 754   TouchFunctor      functor(data);
 755   scene.TouchedSignal().Connect(&application, functor);
 756
 757   // Render and notify.
 758   application.SendNotification();
 759   application.Render();
 760
 761   // Confirm functor not called before there has been any touch event.
 762   DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 763
 764   // No actors, single touch, down, motion then up.
 765   {
 766     GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
 767
 768     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 769     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 770     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 771
 772     data.Reset();
 773
 774     // Confirm there is no signal when the touchpoint is only moved.
 775     GenerateTouch(application, PointState::MOTION, Vector2(1200.0f, 10.0f)); // Some motion
 776
 777     DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
 778     data.Reset();
 779
 780     // Confirm a following up event generates a signal.
 781     GenerateTouch(application, PointState::UP, Vector2(1200.0f, 10.0f));
 782
 783     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 784     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 785     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 786     data.Reset();
 787   }
 788
 789   // Add an actor to the scene.
 790   Actor actor = Actor::New();
 791   actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
 792   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
 793   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
 794   actor.TouchedSignal().Connect(&DummyTouchCallback);
 795   scene.Add(actor);
 796
 797   // Render and notify.
 798   application.SendNotification();
 799   application.Render();
 800
 801   // Actor on scene. Interrupted before down and interrupted after down.
 802   {
 803     GenerateTouch(application, PointState::INTERRUPTED, Vector2(10.0f, 10.0f));
 804
 805     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 806     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 807     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 808     DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED);
 809     data.Reset();
 810
 811     GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
 812
 813     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 814     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 815     DALI_TEST_CHECK(data.receivedTouchEvent.GetHitActor(0) == actor);
 816     DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::DOWN);
 817     data.Reset();
 818
 819     GenerateTouch(application, PointState::INTERRUPTED, Vector2(10.0f, 10.0f));
 820
 821     DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 822     DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
 823     DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
 824     DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED);
 825
 826     DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
 827
 828     // Check that getting info about a non-existent point returns an empty handle
 829     Actor actor = data.receivedTouchEvent.GetHitActor(1);
 830     DALI_TEST_CHECK(!actor);
 831
 832     data.Reset();
 833   }
 834
 835   END_TEST;
 836 }
 837
 838 int UtcDaliSceneSignalWheelEventP(void)
 839 {
 840   TestApplication          application;
 841   Dali::Integration::Scene scene = application.GetScene();
 842
 843   WheelEventSignalData      data;
 844   WheelEventReceivedFunctor functor(data);
 845   scene.WheelEventSignal().Connect(&application, functor);
 846
 847   Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
 848   application.ProcessEvent(event);
 849
 850   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 851   DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event.type) == data.receivedWheelEvent.GetType());
 852   DALI_TEST_CHECK(event.direction == data.receivedWheelEvent.GetDirection());
 853   DALI_TEST_CHECK(event.modifiers == data.receivedWheelEvent.GetModifiers());
 854   DALI_TEST_CHECK(event.point == data.receivedWheelEvent.GetPoint());
 855   DALI_TEST_CHECK(event.delta == data.receivedWheelEvent.GetDelta());
 856   DALI_TEST_CHECK(event.timeStamp == data.receivedWheelEvent.GetTime());
 857
 858   data.Reset();
 859
 860   Integration::WheelEvent event2(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1000u);
 861   application.ProcessEvent(event2);
 862
 863   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
 864   DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event2.type) == data.receivedWheelEvent.GetType());
 865   DALI_TEST_CHECK(event2.direction == data.receivedWheelEvent.GetDirection());
 866   DALI_TEST_CHECK(event2.modifiers == data.receivedWheelEvent.GetModifiers());
 867   DALI_TEST_CHECK(event2.point == data.receivedWheelEvent.GetPoint());
 868   DALI_TEST_CHECK(event2.delta == data.receivedWheelEvent.GetDelta());
 869   DALI_TEST_CHECK(event2.timeStamp == data.receivedWheelEvent.GetTime());
 870   END_TEST;
 871 }
 872
 873 int UtcDaliSceneSurfaceResizedDefaultScene(void)
 874 {
 875   tet_infoline("Ensure resizing of the surface is handled properly");
 876
 877   TestApplication application;
 878
 879   auto defaultScene = application.GetScene();
 880   DALI_TEST_CHECK(defaultScene);
 881
 882   // Ensure stage size matches the scene size
 883   auto stage = Stage::GetCurrent();
 884   DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
 885
 886   // Resize the scene
 887   Vector2 newSize(1000.0f, 2000.0f);
 888   DALI_TEST_CHECK(stage.GetSize() != newSize);
 889   defaultScene.SurfaceResized(newSize.width, newSize.height);
 890
 891   DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
 892   DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
 893
 894   END_TEST;
 895 }
 896
 897 int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void)
 898 {
 899   tet_infoline("Ensure resizing of the surface & viewport is handled properly");
 900
 901   TestApplication    application;
 902   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 903   TraceCallStack&    callStack     = glAbstraction.GetViewportTrace();
 904   glAbstraction.EnableViewportCallTrace(true);
 905
 906   // Initial scene setup
 907   Geometry geometry = CreateQuadGeometry();
 908   Shader   shader   = CreateShader();
 909   Renderer renderer = Renderer::New(geometry, shader);
 910
 911   Actor actor = Actor::New();
 912   actor.AddRenderer(renderer);
 913   actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
 914   application.GetScene().Add(actor);
 915
 916   // Render before resizing surface
 917   application.SendNotification();
 918   application.Render(0);
 919   glAbstraction.ResetViewportCallStack();
 920
 921   auto defaultScene = application.GetScene();
 922   DALI_TEST_CHECK(defaultScene);
 923
 924   // consume the resize flag by first rendering
 925   defaultScene.IsSurfaceRectChanged();
 926
 927   // Ensure stage size matches the scene size
 928   auto stage = Stage::GetCurrent();
 929   DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
 930
 931   Rect<int32_t> surfaceRect = defaultScene.GetCurrentSurfaceRect();
 932
 933   bool surfaceResized;
 934   // check resized flag before surface is resized.
 935   surfaceResized = defaultScene.IsSurfaceRectChanged();
 936   DALI_TEST_EQUALS(surfaceResized, false, TEST_LOCATION);
 937
 938   // Resize the scene
 939   Vector2     newSize(1000.0f, 2000.0f);
 940   std::string viewportParams("0, 0, 1000, 2000"); // to match newSize
 941   DALI_TEST_CHECK(stage.GetSize() != newSize);
 942   defaultScene.SurfaceResized(newSize.width, newSize.height);
 943
 944   DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
 945   DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
 946
 947   // Check current surface rect
 948   Rect<int32_t> newSurfaceRect = defaultScene.GetCurrentSurfaceRect();
 949
 950   // It should not be changed yet.
 951   DALI_TEST_CHECK(surfaceRect == newSurfaceRect);
 952
 953   // Render after resizing surface
 954   application.SendNotification();
 955   application.Render(0);
 956
 957   surfaceResized = defaultScene.IsSurfaceRectChanged();
 958   DALI_TEST_EQUALS(surfaceResized, true, TEST_LOCATION);
 959
 960   // Check that the viewport is handled properly
 961   DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams));
 962
 963   // Check current surface rect
 964   newSurfaceRect = defaultScene.GetCurrentSurfaceRect();
 965
 966   // It should be changed
 967   DALI_TEST_EQUALS(newSurfaceRect.x, 0, TEST_LOCATION);
 968   DALI_TEST_EQUALS(newSurfaceRect.y, 0, TEST_LOCATION);
 969   DALI_TEST_EQUALS(newSurfaceRect.width, 1000, TEST_LOCATION);
 970   DALI_TEST_EQUALS(newSurfaceRect.height, 2000, TEST_LOCATION);
 971
 972   END_TEST;
 973 }
 974
 975 int UtcDaliSceneSurfaceResizedMultipleRenderTasks(void)
 976 {
 977   tet_infoline("Ensure resizing of the surface & viewport is handled properly");
 978
 979   TestApplication    application;
 980   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 981   TraceCallStack&    callStack     = glAbstraction.GetViewportTrace();
 982   glAbstraction.EnableViewportCallTrace(true);
 983
 984   // Initial scene setup
 985   auto scene = application.GetScene();
 986
 987   Geometry geometry = CreateQuadGeometry();
 988   Shader   shader   = CreateShader();
 989   Renderer renderer = Renderer::New(geometry, shader);
 990
 991   Actor actor = Actor::New();
 992   actor.AddRenderer(renderer);
 993   int testWidth  = 400;
 994   int testHeight = 400;
 995   actor.SetProperty(Actor::Property::SIZE, Vector2(testWidth, testHeight));
 996   scene.Add(actor);
 997
 998   CameraActor offscreenCameraActor = CameraActor::New(Size(testWidth, testHeight));
 999   application.GetScene().Add(offscreenCameraActor);
1000
1001   FrameBuffer newFrameBuffer = FrameBuffer::New(testWidth, testHeight, FrameBuffer::Attachment::NONE);
1002
1003   RenderTask newTask = scene.GetRenderTaskList().CreateTask();
1004   newTask.SetCameraActor(offscreenCameraActor);
1005   newTask.SetSourceActor(actor);
1006   newTask.SetFrameBuffer(newFrameBuffer);
1007   newTask.SetViewportPosition(Vector2(0, 0));
1008   newTask.SetViewportSize(Vector2(testWidth, testHeight));
1009
1010   // Render before resizing surface
1011   application.SendNotification();
1012   application.Render(0);
1013   glAbstraction.ResetViewportCallStack();
1014
1015   Rect<int32_t> initialViewport = newTask.GetViewport();
1016   int           initialWidth    = initialViewport.width;
1017   int           initialHeight   = initialViewport.height;
1018   DALI_TEST_EQUALS(initialWidth, testWidth, TEST_LOCATION);
1019   DALI_TEST_EQUALS(initialHeight, testHeight, TEST_LOCATION);
1020
1021   auto defaultScene = application.GetScene();
1022   DALI_TEST_CHECK(defaultScene);
1023
1024   // Ensure stage size matches the scene size
1025   auto stage = Stage::GetCurrent();
1026   DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
1027
1028   // Resize the scene
1029   Vector2     newSize(1000.0f, 2000.0f);
1030   std::string viewportParams("0, 0, 1000, 2000"); // to match newSize
1031   DALI_TEST_CHECK(stage.GetSize() != newSize);
1032   defaultScene.SurfaceResized(newSize.width, newSize.height);
1033
1034   DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
1035   DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
1036
1037   // Render after resizing surface
1038   application.SendNotification();
1039   application.Render(0);
1040
1041   // Check that the viewport is handled properly
1042   DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams));
1043
1044   // Second render-task should not be affected
1045   Rect<int32_t> viewport = newTask.GetViewport();
1046   int           width    = viewport.width;
1047   int           height   = viewport.height;
1048   DALI_TEST_EQUALS(width, testWidth, TEST_LOCATION);
1049   DALI_TEST_EQUALS(height, testHeight, TEST_LOCATION);
1050
1051   END_TEST;
1052 }
1053
1054 int UtcDaliSceneSurfaceResizedAdditionalScene(void)
1055 {
1056   tet_infoline("Ensure resizing of the surface is handled properly on additional scenes");
1057
1058   TestApplication application;
1059   Vector2         originalSurfaceSize(500.0f, 1000.0f);
1060
1061   auto scene = Integration::Scene::New(Size(originalSurfaceSize.width, originalSurfaceSize.height));
1062
1063   // Ensure stage size does NOT match the surface size
1064   auto       stage     = Stage::GetCurrent();
1065   const auto stageSize = stage.GetSize();
1066   DALI_TEST_CHECK(stageSize != originalSurfaceSize);
1067   DALI_TEST_EQUALS(originalSurfaceSize, scene.GetSize(), TEST_LOCATION);
1068
1069   // Resize the surface and inform the scene accordingly
1070   Vector2 newSize(1000.0f, 2000.0f);
1071   DALI_TEST_CHECK(stage.GetSize() != newSize);
1072   scene.SurfaceResized(newSize.width, newSize.height);
1073
1074   // Ensure the stage hasn't been resized
1075   DALI_TEST_EQUALS(stage.GetSize(), stageSize, TEST_LOCATION);
1076   DALI_TEST_EQUALS(scene.GetSize(), newSize, TEST_LOCATION);
1077
1078   END_TEST;
1079 }
1080
1081 #define CLIPPING_RECT_X (16)
1082 #define CLIPPING_RECT_Y (768)
1083 #define CLIPPING_RECT_WIDTH (32)
1084 #define CLIPPING_RECT_HEIGHT (32)
1085
1086 int UtcDaliSceneSurfaceRotatedWithAngle0(void)
1087 {
1088   tet_infoline("Ensure rotation of the surface is handled properly with Angle 0");
1089
1090   TestApplication application(
1091     TestApplication::DEFAULT_SURFACE_WIDTH,
1092     TestApplication::DEFAULT_SURFACE_HEIGHT,
1093     TestApplication::DEFAULT_HORIZONTAL_DPI,
1094     TestApplication::DEFAULT_VERTICAL_DPI,
1095     true,
1096     true);
1097
1098   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1099
1100   std::vector<Rect<int>> damagedRects;
1101   Rect<int>              clippingRect;
1102   application.SendNotification();
1103   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1104
1105   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1106
1107   clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1108   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1109
1110   Actor actor = CreateRenderableActor();
1111   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1112   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1113   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1114   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1115   application.GetScene().Add(actor);
1116
1117   application.SendNotification();
1118
1119   damagedRects.clear();
1120   application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1121                                         TestApplication::DEFAULT_SURFACE_HEIGHT,
1122                                         0);
1123
1124   // Check current surface orientation
1125   int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1126
1127   // It should not be changed yet.
1128   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1129
1130   application.SendNotification();
1131   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1132   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1133
1134   clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1135   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1136   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1137
1138   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1139   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1140   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1141   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1142
1143   // Check current surface orientation
1144   orientation = application.GetScene().GetCurrentSurfaceOrientation();
1145
1146   // It should be changed.
1147   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1148
1149   END_TEST;
1150 }
1151
1152 int UtcDaliSceneSurfaceRotatedWithAngle90(void)
1153 {
1154   tet_infoline("Ensure rotation of the surface is handled properly with Angle 90");
1155
1156   TestApplication application(
1157     TestApplication::DEFAULT_SURFACE_WIDTH,
1158     TestApplication::DEFAULT_SURFACE_HEIGHT,
1159     TestApplication::DEFAULT_HORIZONTAL_DPI,
1160     TestApplication::DEFAULT_VERTICAL_DPI,
1161     true,
1162     true);
1163
1164   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1165
1166   std::vector<Rect<int>> damagedRects;
1167   Rect<int>              clippingRect;
1168   application.SendNotification();
1169   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1170
1171   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1172
1173   clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1174   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1175
1176   Actor actor = CreateRenderableActor();
1177   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1178   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1179   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1180   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1181   application.GetScene().Add(actor);
1182
1183   application.SendNotification();
1184
1185   damagedRects.clear();
1186   application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1187                                         TestApplication::DEFAULT_SURFACE_HEIGHT,
1188                                         90);
1189
1190   // Check current surface orientation
1191   int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1192
1193   // It should not be changed yet.
1194   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1195
1196   application.SendNotification();
1197   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1198   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1199
1200   clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1201   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1202   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1203
1204   // It is recalculation for glScissor.
1205   // Because surface is rotated and glScissor is called with recalcurated value.
1206   clippingRect.x      = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1207   clippingRect.y      = CLIPPING_RECT_X;
1208   clippingRect.width  = CLIPPING_RECT_HEIGHT;
1209   clippingRect.height = CLIPPING_RECT_WIDTH;
1210
1211   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1212   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1213   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1214   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1215
1216   // Check current surface orientation
1217   orientation = application.GetScene().GetCurrentSurfaceOrientation();
1218
1219   // It should be changed.
1220   DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION);
1221
1222   END_TEST;
1223 }
1224
1225 int UtcDaliSceneSurfaceRotatedWithAngle180(void)
1226 {
1227   tet_infoline("Ensure rotation of the surface is handled properly with Angle 180");
1228
1229   TestApplication application(
1230     TestApplication::DEFAULT_SURFACE_WIDTH,
1231     TestApplication::DEFAULT_SURFACE_HEIGHT,
1232     TestApplication::DEFAULT_HORIZONTAL_DPI,
1233     TestApplication::DEFAULT_VERTICAL_DPI,
1234     true,
1235     true);
1236
1237   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1238
1239   std::vector<Rect<int>> damagedRects;
1240   Rect<int>              clippingRect;
1241   application.SendNotification();
1242   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1243
1244   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1245
1246   clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1247   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1248
1249   Actor actor = CreateRenderableActor();
1250   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1251   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1252   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1253   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1254   application.GetScene().Add(actor);
1255
1256   application.SendNotification();
1257
1258   damagedRects.clear();
1259   application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1260                                         TestApplication::DEFAULT_SURFACE_HEIGHT,
1261                                         180);
1262
1263   // Check current surface orientation
1264   int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1265
1266   // It should not be changed yet.
1267   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1268
1269   application.SendNotification();
1270   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1271   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1272
1273   clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1274   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1275   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1276
1277   // It is recalculation for glScissor.
1278   // Because surface is rotated and glScissor is called with recalcurated value.
1279   clippingRect.x      = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
1280   clippingRect.y      = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1281   clippingRect.width  = CLIPPING_RECT_WIDTH;
1282   clippingRect.height = CLIPPING_RECT_HEIGHT;
1283
1284   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1285   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1286   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1287   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1288
1289   // Check current surface orientation
1290   orientation = application.GetScene().GetCurrentSurfaceOrientation();
1291
1292   // It should be changed.
1293   DALI_TEST_EQUALS(orientation, 180, TEST_LOCATION);
1294
1295   END_TEST;
1296 }
1297
1298 int UtcDaliSceneSurfaceRotatedWithAngle270(void)
1299 {
1300   tet_infoline("Ensure rotation of the surface is handled properly with Angle 270");
1301
1302   TestApplication application(
1303     TestApplication::DEFAULT_SURFACE_WIDTH,
1304     TestApplication::DEFAULT_SURFACE_HEIGHT,
1305     TestApplication::DEFAULT_HORIZONTAL_DPI,
1306     TestApplication::DEFAULT_VERTICAL_DPI,
1307     true,
1308     true);
1309
1310   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1311
1312   std::vector<Rect<int>> damagedRects;
1313   Rect<int>              clippingRect;
1314   application.SendNotification();
1315   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1316
1317   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1318
1319   clippingRect = TestApplication::DEFAULT_SURFACE_RECT;
1320   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1321
1322   Actor actor = CreateRenderableActor();
1323   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1324   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1325   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1326   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1327   application.GetScene().Add(actor);
1328
1329   application.SendNotification();
1330
1331   damagedRects.clear();
1332   application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1333                                         TestApplication::DEFAULT_SURFACE_HEIGHT,
1334                                         270);
1335
1336   // Check current surface orientation
1337   int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1338
1339   // It should not be changed yet.
1340   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1341
1342   application.SendNotification();
1343   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1344   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1345
1346   clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1347   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1348   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1349
1350   // It is recalculation for glScissor.
1351   // Because surface is rotated and glScissor is called with recalcurated value.
1352   clippingRect.x      = CLIPPING_RECT_Y;
1353   clippingRect.y      = TestApplication::DEFAULT_SURFACE_WIDTH - (CLIPPING_RECT_X + CLIPPING_RECT_WIDTH);
1354   clippingRect.width  = CLIPPING_RECT_HEIGHT;
1355   clippingRect.height = CLIPPING_RECT_WIDTH;
1356
1357   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1358   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1359   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1360   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1361
1362   // Check current surface orientation
1363   orientation = application.GetScene().GetCurrentSurfaceOrientation();
1364
1365   // It should be changed.
1366   DALI_TEST_EQUALS(orientation, 270, TEST_LOCATION);
1367
1368   END_TEST;
1369 }
1370
1371 int UtcDaliSceneSetRotationCompletedAcknowledgementWithAngle90(void)
1372 {
1373   tet_infoline("Ensure to acknowledge for completing surface 90 angle rotaiton");
1374
1375   TestApplication application(
1376     TestApplication::DEFAULT_SURFACE_WIDTH,
1377     TestApplication::DEFAULT_SURFACE_HEIGHT,
1378     TestApplication::DEFAULT_HORIZONTAL_DPI,
1379     TestApplication::DEFAULT_VERTICAL_DPI,
1380     true,
1381     true);
1382
1383   const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
1384
1385   std::vector<Rect<int>> damagedRects;
1386   Rect<int>              clippingRect;
1387   application.SendNotification();
1388   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1389
1390   DALI_TEST_EQUALS(damagedRects.size(), 0, TEST_LOCATION);
1391   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1392
1393   Actor actor = CreateRenderableActor();
1394   actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1395   actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
1396   actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
1397   actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
1398   application.GetScene().Add(actor);
1399
1400   application.SendNotification();
1401
1402   damagedRects.clear();
1403   application.GetScene().SurfaceRotated(TestApplication::DEFAULT_SURFACE_WIDTH,
1404                                         TestApplication::DEFAULT_SURFACE_HEIGHT,
1405                                         90);
1406
1407   // Check current surface orientation
1408   int32_t orientation = application.GetScene().GetCurrentSurfaceOrientation();
1409
1410   // It should not be changed yet.
1411   DALI_TEST_EQUALS(orientation, 0, TEST_LOCATION);
1412
1413   application.GetScene().SetRotationCompletedAcknowledgement();
1414
1415   application.SendNotification();
1416   application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
1417   DALI_TEST_EQUALS(damagedRects.size(), 1, TEST_LOCATION);
1418
1419   clippingRect = Rect<int>(CLIPPING_RECT_X, CLIPPING_RECT_Y, CLIPPING_RECT_WIDTH, CLIPPING_RECT_HEIGHT); // in screen coordinates, includes 3 last frames updates
1420   DALI_TEST_EQUALS<Rect<int>>(clippingRect, damagedRects[0], TEST_LOCATION);
1421   application.RenderWithPartialUpdate(damagedRects, clippingRect);
1422
1423   // It is recalculation for glScissor.
1424   // Because surface is rotated and glScissor is called with recalcurated value.
1425   clippingRect.x      = TestApplication::DEFAULT_SURFACE_HEIGHT - (CLIPPING_RECT_Y + CLIPPING_RECT_HEIGHT);
1426   clippingRect.y      = CLIPPING_RECT_X;
1427   clippingRect.width  = CLIPPING_RECT_HEIGHT;
1428   clippingRect.height = CLIPPING_RECT_WIDTH;
1429
1430   DALI_TEST_EQUALS(clippingRect.x, glScissorParams.x, TEST_LOCATION);
1431   DALI_TEST_EQUALS(clippingRect.y, glScissorParams.y, TEST_LOCATION);
1432   DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
1433   DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
1434
1435   // Check current surface orientation
1436   orientation = application.GetScene().GetCurrentSurfaceOrientation();
1437
1438   // It should be changed.
1439   DALI_TEST_EQUALS(orientation, 90, TEST_LOCATION);
1440
1441   bool isSetRotationCompletedAcknowledgementSet = application.GetScene().IsRotationCompletedAcknowledgementSet();
1442   DALI_TEST_EQUALS(isSetRotationCompletedAcknowledgementSet, true, TEST_LOCATION);
1443
1444   END_TEST;
1445 }
1446
1447
1448
1449 int UtcDaliSceneKeyEventGeneratedSignalP(void)
1450 {
1451   TestApplication          application;
1452   Dali::Integration::Scene scene = application.GetScene();
1453
1454   KeyEventGeneratedSignalData      data;
1455   KeyEventGeneratedReceivedFunctor functor(data);
1456   scene.KeyEventGeneratedSignal().Connect(&application, functor);
1457
1458   Integration::KeyEvent event("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1459   application.ProcessEvent(event);
1460
1461   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1462   DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1463   DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
1464   DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
1465   DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1466
1467   data.Reset();
1468
1469   Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1470   application.ProcessEvent(event2);
1471
1472   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1473   DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1474   DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
1475   DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
1476   DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1477
1478   data.Reset();
1479
1480   Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1481   application.ProcessEvent(event3);
1482
1483   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1484   DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1485   DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
1486   DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
1487   DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1488
1489   data.Reset();
1490
1491   Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1492   application.ProcessEvent(event4);
1493
1494   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1495   DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1496   DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
1497   DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
1498   DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1499   END_TEST;
1500 }
1501
1502 int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void)
1503 {
1504   tet_infoline("Ensure we keep background color when the scene surface is replaced ");
1505
1506   TestApplication application;
1507
1508   // Create a new scene and set the background color of the main scene
1509   auto defaultScene = application.GetScene();
1510   defaultScene.SetBackgroundColor(Color::BLUE);
1511
1512   // Need to create a renderable as we don't start rendering until we have at least one
1513   // We don't need to add this to any scene
1514   auto actor = CreateRenderableActor();
1515
1516   auto& glAbstraction    = application.GetGlAbstraction();
1517   auto  clearCountBefore = glAbstraction.GetClearCountCalled();
1518
1519   application.SendNotification();
1520   application.Render();
1521
1522   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION);
1523   DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
1524
1525   defaultScene.SurfaceReplaced();
1526
1527   application.SendNotification();
1528   application.Render();
1529
1530   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION);
1531   DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
1532
1533   // Check when the main render task viewport is set the clear color is clipped using scissors
1534   TraceCallStack& scissorTrace        = glAbstraction.GetScissorTrace();
1535   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
1536   scissorTrace.Enable(true);
1537   enabledDisableTrace.Enable(true);
1538
1539   defaultScene.GetRenderTaskList().GetTask(0).SetViewport(Viewport(0.0f, 0.0f, 100.0f, 100.0f));
1540
1541   application.SendNotification();
1542   application.Render();
1543
1544   // Check scissor test was enabled.
1545   std::ostringstream scissor;
1546   scissor << std::hex << GL_SCISSOR_TEST;
1547   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", scissor.str()));
1548
1549   // Check the scissor was set, and the coordinates are correct.
1550   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", "0, 700, 100, 100"));
1551
1552   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION);
1553   DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
1554
1555   scissorTrace.Enable(false);
1556   scissorTrace.Reset();
1557
1558   enabledDisableTrace.Enable(false);
1559   enabledDisableTrace.Reset();
1560
1561   END_TEST;
1562 }
1563
1564 int UtcDaliSceneEmptySceneRendering(void)
1565 {
1566   tet_infoline("Ensure not rendering before a Renderer is added");
1567
1568   TestApplication    application;
1569   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1570
1571   // Render without any renderer
1572   application.SendNotification();
1573   application.Render();
1574
1575   // Check the clear count and the render status
1576   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 0, TEST_LOCATION);
1577   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), false, TEST_LOCATION);
1578
1579   // Add a Renderer
1580   Geometry geometry = CreateQuadGeometry();
1581   Shader   shader   = CreateShader();
1582   Renderer renderer = Renderer::New(geometry, shader);
1583
1584   // Render before adding renderer
1585   application.SendNotification();
1586   application.Render();
1587
1588   // Check the clear count and the render status
1589   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 0, TEST_LOCATION);
1590   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), false, TEST_LOCATION);
1591
1592   Actor actor = Actor::New();
1593   actor.AddRenderer(renderer);
1594
1595   actor.SetProperty(Actor::Property::SIZE, Vector2(400, 400));
1596   application.GetScene().Add(actor);
1597
1598   // Render
1599   application.SendNotification();
1600   application.Render();
1601
1602   // Check the clear count and the render status
1603   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 1, TEST_LOCATION);
1604   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), true, TEST_LOCATION);
1605
1606   // Remove the Renderer
1607   application.GetScene().Remove(actor);
1608   actor.Reset();
1609   renderer.Reset();
1610
1611   // Render
1612   application.SendNotification();
1613   application.Render();
1614
1615   // Check the clear count and the render status
1616   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 2, TEST_LOCATION); // Should be cleared
1617   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), true, TEST_LOCATION);
1618
1619   END_TEST;
1620 }
1621
1622 int UtcDaliSceneFrameRenderedPresentedCallback(void)
1623 {
1624   tet_infoline("UtcDaliSceneFrameRenderedCallback");
1625
1626   TestApplication application;
1627
1628   // Add a Renderer
1629   Geometry geometry = CreateQuadGeometry();
1630   Shader   shader   = CreateShader();
1631   Renderer renderer = Renderer::New(geometry, shader);
1632
1633   Actor actor = Actor::New();
1634   actor.AddRenderer(renderer);
1635   application.GetScene().Add(actor);
1636
1637   Dali::Integration::Scene scene = application.GetScene();
1638
1639   int frameId = 1;
1640   scene.AddFrameRenderedCallback(std::unique_ptr<CallbackBase>(MakeCallback(&FrameCallback)), frameId);
1641   scene.AddFramePresentedCallback(std::unique_ptr<CallbackBase>(MakeCallback(&FrameCallback)), frameId);
1642
1643   // Render
1644   application.SendNotification();
1645   application.Render();
1646
1647   Dali::Integration::Scene::FrameCallbackContainer callbackContainer;
1648   scene.GetFrameRenderedCallback(callbackContainer);
1649
1650   DALI_TEST_EQUALS(callbackContainer.size(), 1, TEST_LOCATION);
1651   DALI_TEST_EQUALS(callbackContainer[0].second, frameId, TEST_LOCATION);
1652
1653   callbackContainer.clear();
1654
1655   scene.GetFramePresentedCallback(callbackContainer);
1656
1657   DALI_TEST_EQUALS(callbackContainer.size(), 1, TEST_LOCATION);
1658   DALI_TEST_EQUALS(callbackContainer[0].second, frameId, TEST_LOCATION);
1659
1660   END_TEST;
1661 }