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

   1 /*
   2  * Copyright (c) 2020 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
 890   defaultScene.SurfaceResized(newSize.width, newSize.height, 0, false);
 891
 892   DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
 893   DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
 894
 895   END_TEST;
 896 }
 897
 898 int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void)
 899 {
 900   tet_infoline("Ensure resizing of the surface & viewport is handled properly");
 901
 902   TestApplication    application;
 903   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 904   TraceCallStack&    callStack     = glAbstraction.GetViewportTrace();
 905   glAbstraction.EnableViewportCallTrace(true);
 906
 907   // Initial scene setup
 908   Geometry geometry = CreateQuadGeometry();
 909   Shader   shader   = CreateShader();
 910   Renderer renderer = Renderer::New(geometry, shader);
 911
 912   Actor actor = Actor::New();
 913   actor.AddRenderer(renderer);
 914   actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
 915   application.GetScene().Add(actor);
 916
 917   // Render before resizing surface
 918   application.SendNotification();
 919   application.Render(0);
 920   glAbstraction.ResetViewportCallStack();
 921
 922   auto defaultScene = application.GetScene();
 923   DALI_TEST_CHECK(defaultScene);
 924
 925   // Ensure stage size matches the scene size
 926   auto stage = Stage::GetCurrent();
 927   DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
 928
 929   // Resize the scene
 930   Vector2     newSize(1000.0f, 2000.0f);
 931   std::string viewportParams("0, 0, 1000, 2000"); // to match newSize
 932   DALI_TEST_CHECK(stage.GetSize() != newSize);
 933   defaultScene.SurfaceResized(newSize.width, newSize.height, 0, false);
 934
 935   DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
 936   DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
 937
 938   // Render after resizing surface
 939   application.SendNotification();
 940   application.Render(0);
 941
 942   // Check that the viewport is handled properly
 943   DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams));
 944
 945   END_TEST;
 946 }
 947
 948 int UtcDaliSceneSurfaceResizedMultipleRenderTasks(void)
 949 {
 950   tet_infoline("Ensure resizing of the surface & viewport is handled properly");
 951
 952   TestApplication    application;
 953   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 954   TraceCallStack&    callStack     = glAbstraction.GetViewportTrace();
 955   glAbstraction.EnableViewportCallTrace(true);
 956
 957   // Initial scene setup
 958   auto scene = application.GetScene();
 959
 960   Geometry geometry = CreateQuadGeometry();
 961   Shader   shader   = CreateShader();
 962   Renderer renderer = Renderer::New(geometry, shader);
 963
 964   Actor actor = Actor::New();
 965   actor.AddRenderer(renderer);
 966   int testWidth  = 400;
 967   int testHeight = 400;
 968   actor.SetProperty(Actor::Property::SIZE, Vector2(testWidth, testHeight));
 969   scene.Add(actor);
 970
 971   CameraActor offscreenCameraActor = CameraActor::New(Size(testWidth, testHeight));
 972   application.GetScene().Add(offscreenCameraActor);
 973
 974   FrameBuffer newFrameBuffer = FrameBuffer::New(testWidth, testHeight, FrameBuffer::Attachment::NONE);
 975
 976   RenderTask newTask = scene.GetRenderTaskList().CreateTask();
 977   newTask.SetCameraActor(offscreenCameraActor);
 978   newTask.SetSourceActor(actor);
 979   newTask.SetFrameBuffer(newFrameBuffer);
 980   newTask.SetViewportPosition(Vector2(0, 0));
 981   newTask.SetViewportSize(Vector2(testWidth, testHeight));
 982
 983   // Render before resizing surface
 984   application.SendNotification();
 985   application.Render(0);
 986   glAbstraction.ResetViewportCallStack();
 987
 988   Rect<int32_t> initialViewport = newTask.GetViewport();
 989   int           initialWidth    = initialViewport.width;
 990   int           initialHeight   = initialViewport.height;
 991   DALI_TEST_EQUALS(initialWidth, testWidth, TEST_LOCATION);
 992   DALI_TEST_EQUALS(initialHeight, testHeight, TEST_LOCATION);
 993
 994   auto defaultScene = application.GetScene();
 995   DALI_TEST_CHECK(defaultScene);
 996
 997   // Ensure stage size matches the scene size
 998   auto stage = Stage::GetCurrent();
 999   DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
1000
1001   // Resize the scene
1002   Vector2     newSize(1000.0f, 2000.0f);
1003   std::string viewportParams("0, 0, 1000, 2000"); // to match newSize
1004   DALI_TEST_CHECK(stage.GetSize() != newSize);
1005   defaultScene.SurfaceResized(newSize.width, newSize.height, 0, false);
1006
1007   DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
1008   DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
1009
1010   // Render after resizing surface
1011   application.SendNotification();
1012   application.Render(0);
1013
1014   // Check that the viewport is handled properly
1015   DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams));
1016
1017   // Second render-task should not be affected
1018   Rect<int32_t> viewport = newTask.GetViewport();
1019   int           width    = viewport.width;
1020   int           height   = viewport.height;
1021   DALI_TEST_EQUALS(width, testWidth, TEST_LOCATION);
1022   DALI_TEST_EQUALS(height, testHeight, TEST_LOCATION);
1023
1024   END_TEST;
1025 }
1026
1027 int UtcDaliSceneSurfaceResizedAdditionalScene(void)
1028 {
1029   tet_infoline("Ensure resizing of the surface is handled properly on additional scenes");
1030
1031   TestApplication application;
1032   Vector2         originalSurfaceSize(500.0f, 1000.0f);
1033
1034   auto scene = Integration::Scene::New(Size(originalSurfaceSize.width, originalSurfaceSize.height));
1035
1036   // Ensure stage size does NOT match the surface size
1037   auto       stage     = Stage::GetCurrent();
1038   const auto stageSize = stage.GetSize();
1039   DALI_TEST_CHECK(stageSize != originalSurfaceSize);
1040   DALI_TEST_EQUALS(originalSurfaceSize, scene.GetSize(), TEST_LOCATION);
1041
1042   // Resize the surface and inform the scene accordingly
1043   Vector2 newSize(1000.0f, 2000.0f);
1044   DALI_TEST_CHECK(stage.GetSize() != newSize);
1045
1046   scene.SurfaceResized(newSize.width, newSize.height, 0, false);
1047
1048   // Ensure the stage hasn't been resized
1049   DALI_TEST_EQUALS(stage.GetSize(), stageSize, TEST_LOCATION);
1050   DALI_TEST_EQUALS(scene.GetSize(), newSize, TEST_LOCATION);
1051
1052   END_TEST;
1053 }
1054
1055 int UtcDaliSceneKeyEventGeneratedSignalP(void)
1056 {
1057   TestApplication          application;
1058   Dali::Integration::Scene scene = application.GetScene();
1059
1060   KeyEventGeneratedSignalData      data;
1061   KeyEventGeneratedReceivedFunctor functor(data);
1062   scene.KeyEventGeneratedSignal().Connect(&application, functor);
1063
1064   Integration::KeyEvent event("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1065   application.ProcessEvent(event);
1066
1067   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1068   DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1069   DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
1070   DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
1071   DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1072
1073   data.Reset();
1074
1075   Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1076   application.ProcessEvent(event2);
1077
1078   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1079   DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1080   DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
1081   DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
1082   DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1083
1084   data.Reset();
1085
1086   Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1087   application.ProcessEvent(event3);
1088
1089   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1090   DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1091   DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
1092   DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
1093   DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1094
1095   data.Reset();
1096
1097   Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
1098   application.ProcessEvent(event4);
1099
1100   DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
1101   DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
1102   DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
1103   DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
1104   DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
1105   END_TEST;
1106 }
1107
1108 int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void)
1109 {
1110   tet_infoline("Ensure we keep background color when the scene surface is replaced ");
1111
1112   TestApplication application;
1113
1114   // Create a new scene and set the background color of the main scene
1115   auto defaultScene = application.GetScene();
1116   defaultScene.SetBackgroundColor(Color::BLUE);
1117
1118   // Need to create a renderable as we don't start rendering until we have at least one
1119   // We don't need to add this to any scene
1120   auto actor = CreateRenderableActor();
1121
1122   auto& glAbstraction    = application.GetGlAbstraction();
1123   auto  clearCountBefore = glAbstraction.GetClearCountCalled();
1124
1125   application.SendNotification();
1126   application.Render();
1127
1128   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION);
1129   DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
1130
1131   defaultScene.SurfaceReplaced();
1132
1133   application.SendNotification();
1134   application.Render();
1135
1136   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION);
1137   DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
1138
1139   // Check when the main render task viewport is set the clear color is clipped using scissors
1140   TraceCallStack& scissorTrace        = glAbstraction.GetScissorTrace();
1141   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
1142   scissorTrace.Enable(true);
1143   enabledDisableTrace.Enable(true);
1144
1145   defaultScene.GetRenderTaskList().GetTask(0).SetViewport(Viewport(0.0f, 0.0f, 100.0f, 100.0f));
1146
1147   application.SendNotification();
1148   application.Render();
1149
1150   // Check scissor test was enabled.
1151   DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", "3089")); // 3089 = 0xC11 (GL_SCISSOR_TEST)
1152
1153   // Check the scissor was set, and the coordinates are correct.
1154   DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", "0, 700, 100, 100"));
1155
1156   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION);
1157   DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
1158
1159   scissorTrace.Enable(false);
1160   scissorTrace.Reset();
1161
1162   enabledDisableTrace.Enable(false);
1163   enabledDisableTrace.Reset();
1164
1165   END_TEST;
1166 }
1167
1168 int UtcDaliSceneEmptySceneRendering(void)
1169 {
1170   tet_infoline("Ensure not rendering before a Renderer is added");
1171
1172   TestApplication    application;
1173   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1174
1175   // Render without any renderer
1176   application.SendNotification();
1177   application.Render();
1178
1179   // Check the clear count and the render status
1180   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 0, TEST_LOCATION);
1181   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), false, TEST_LOCATION);
1182
1183   // Add a Renderer
1184   Geometry geometry = CreateQuadGeometry();
1185   Shader   shader   = CreateShader();
1186   Renderer renderer = Renderer::New(geometry, shader);
1187
1188   Actor actor = Actor::New();
1189   actor.AddRenderer(renderer);
1190
1191   actor.SetProperty(Actor::Property::SIZE, Vector2(400, 400));
1192   application.GetScene().Add(actor);
1193
1194   // Render
1195   application.SendNotification();
1196   application.Render();
1197
1198   // Check the clear count and the render status
1199   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 1, TEST_LOCATION);
1200   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), true, TEST_LOCATION);
1201
1202   // Remove the Renderer
1203   application.GetScene().Remove(actor);
1204   actor.Reset();
1205   renderer.Reset();
1206
1207   // Render
1208   application.SendNotification();
1209   application.Render();
1210
1211   // Check the clear count and the render status
1212   DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 2, TEST_LOCATION); // Should be cleared
1213   DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), true, TEST_LOCATION);
1214
1215   END_TEST;
1216 }
1217
1218 int UtcDaliSceneFrameRenderedPresentedCallback(void)
1219 {
1220   tet_infoline("UtcDaliSceneFrameRenderedCallback");
1221
1222   TestApplication application;
1223
1224   // Add a Renderer
1225   Geometry geometry = CreateQuadGeometry();
1226   Shader   shader   = CreateShader();
1227   Renderer renderer = Renderer::New(geometry, shader);
1228
1229   Actor actor = Actor::New();
1230   actor.AddRenderer(renderer);
1231   application.GetScene().Add(actor);
1232
1233   Dali::Integration::Scene scene = application.GetScene();
1234
1235   int frameId = 1;
1236   scene.AddFrameRenderedCallback(std::unique_ptr<CallbackBase>(MakeCallback(&FrameCallback)), frameId);
1237   scene.AddFramePresentedCallback(std::unique_ptr<CallbackBase>(MakeCallback(&FrameCallback)), frameId);
1238
1239   // Render
1240   application.SendNotification();
1241   application.Render();
1242
1243   Dali::Integration::Scene::FrameCallbackContainer callbackContainer;
1244   scene.GetFrameRenderedCallback(callbackContainer);
1245
1246   DALI_TEST_EQUALS(callbackContainer.size(), 1, TEST_LOCATION);
1247   DALI_TEST_EQUALS(callbackContainer[0].second, frameId, TEST_LOCATION);
1248
1249   callbackContainer.clear();
1250
1251   scene.GetFramePresentedCallback(callbackContainer);
1252
1253   DALI_TEST_EQUALS(callbackContainer.size(), 1, TEST_LOCATION);
1254   DALI_TEST_EQUALS(callbackContainer[0].second, frameId, TEST_LOCATION);
1255
1256   END_TEST;
1257 }