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 <iostream>
  19
  20 #include <stdlib.h>
  21 #include <dali/integration-api/scene.h>
  22 #include <dali/integration-api/events/key-event-integ.h>
  23 #include <dali/public-api/events/key-event.h>
  24 #include <dali/devel-api/common/stage.h>
  25 #include <dali/integration-api/events/touch-event-integ.h>
  26 #include <dali/integration-api/events/wheel-event-integ.h>
  27
  28 #include <dali-test-suite-utils.h>
  29 #include <mesh-builder.h>
  30
  31 // Internal headers are allowed here
  32
  33 namespace
  34 {
  35
  36 const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
  37
  38 // Functor for EventProcessingFinished signal
  39 struct EventProcessingFinishedFunctor
  40 {
  41   /**
  42    * @param[in] eventProcessingFinished reference to a boolean variable used to check if signal has been called.
  43    */
  44   EventProcessingFinishedFunctor( bool& eventProcessingFinished )
  45   : mEventProcessingFinished( eventProcessingFinished )
  46   {}
  47
  48   void operator()()
  49   {
  50     mEventProcessingFinished = true;
  51   }
  52
  53   bool& mEventProcessingFinished;
  54 };
  55
  56 // Stores data that is populated in the key-event callback and will be read by the TET cases
  57 struct KeyEventSignalData
  58 {
  59   KeyEventSignalData()
  60   : functorCalled(false)
  61   {}
  62
  63   void Reset()
  64   {
  65     functorCalled = false;
  66
  67     receivedKeyEvent.keyModifier = 0;
  68     receivedKeyEvent.keyPressedName.clear();
  69     receivedKeyEvent.keyPressed.clear();
  70   }
  71
  72   bool functorCalled;
  73   KeyEvent receivedKeyEvent;
  74 };
  75
  76 // Functor that sets the data when called
  77 struct KeyEventReceivedFunctor
  78 {
  79   KeyEventReceivedFunctor( KeyEventSignalData& data ) : signalData( data ) { }
  80
  81   bool operator()( const KeyEvent& keyEvent )
  82   {
  83     signalData.functorCalled = true;
  84     signalData.receivedKeyEvent = keyEvent;
  85
  86     return true;
  87   }
  88
  89   KeyEventSignalData& signalData;
  90 };
  91
  92 // Stores data that is populated in the touched signal callback and will be read by the TET cases
  93 struct TouchedSignalData
  94 {
  95   TouchedSignalData()
  96   : functorCalled(false),
  97     createNewScene(false),
  98     newSceneCreated(false)
  99   {}
 100
 101   void Reset()
 102   {
 103     functorCalled = false;
 104     createNewScene = false;
 105     newSceneCreated = false;
 106
 107     receivedTouchEvent.points.clear();
 108     receivedTouchEvent.time = 0;
 109
 110     receivedTouchData.Reset();
 111   }
 112
 113   bool functorCalled;
 114   bool createNewScene;
 115   bool newSceneCreated;
 116   TouchEvent receivedTouchEvent;
 117   TouchData receivedTouchData;
 118 };
 119
 120 // Functor that sets the data when touched signal is received
 121 struct TouchedFunctor
 122 {
 123   TouchedFunctor( TouchedSignalData& data ) : signalData( data ) { }
 124
 125   void operator()( const TouchEvent& touch )
 126   {
 127     signalData.functorCalled = true;
 128     signalData.receivedTouchEvent = touch;
 129   }
 130
 131   TouchedSignalData& signalData;
 132 };
 133
 134 // Functor that sets the data when touched signal is received
 135 struct TouchFunctor
 136 {
 137   TouchFunctor( TouchedSignalData& data ) : signalData( data ) { }
 138
 139   void operator()( const TouchData& touch )
 140   {
 141     signalData.functorCalled = true;
 142     signalData.receivedTouchData = touch;
 143
 144     if ( signalData.createNewScene )
 145     {
 146       Dali::Integration::Scene scene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f  ) );
 147       DALI_TEST_CHECK( scene );
 148
 149       signalData.newSceneCreated = true;
 150     }
 151   }
 152
 153   void operator()()
 154   {
 155     signalData.functorCalled = true;
 156   }
 157
 158   TouchedSignalData& signalData;
 159 };
 160
 161 // Stores data that is populated in the wheel-event callback and will be read by the TET cases
 162 struct WheelEventSignalData
 163 {
 164   WheelEventSignalData()
 165   : functorCalled(false)
 166   {}
 167
 168   void Reset()
 169   {
 170     functorCalled = false;
 171   }
 172
 173   bool functorCalled;
 174   WheelEvent receivedWheelEvent;
 175 };
 176
 177 // Functor that sets the data when wheel-event signal is received
 178 struct WheelEventReceivedFunctor
 179 {
 180   WheelEventReceivedFunctor( WheelEventSignalData& data ) : signalData( data ) { }
 181
 182   bool operator()( const WheelEvent& wheelEvent )
 183   {
 184     signalData.functorCalled = true;
 185     signalData.receivedWheelEvent = wheelEvent;
 186
 187     return true;
 188   }
 189
 190   WheelEventSignalData& signalData;
 191 };
 192
 193 // Stores data that is populated in the KeyEventGeneratedSignal callback and will be read by the TET cases
 194 struct KeyEventGeneratedSignalData
 195 {
 196   KeyEventGeneratedSignalData()
 197   : functorCalled(false)
 198   {}
 199
 200   void Reset()
 201   {
 202     functorCalled = false;
 203
 204     receivedKeyEvent.keyModifier = 0;
 205     receivedKeyEvent.keyPressedName.clear();
 206     receivedKeyEvent.keyPressed.clear();
 207   }
 208
 209   bool functorCalled;
 210   KeyEvent receivedKeyEvent;
 211 };
 212
 213 // Functor that sets the data when called
 214 struct KeyEventGeneratedReceivedFunctor
 215 {
 216   KeyEventGeneratedReceivedFunctor( KeyEventGeneratedSignalData& data )
 217   : signalData( data )
 218   {}
 219
 220   bool operator()( const KeyEvent& keyEvent )
 221   {
 222     signalData.functorCalled = true;
 223     signalData.receivedKeyEvent = keyEvent;
 224
 225     return true;
 226   }
 227
 228   bool operator()()
 229   {
 230     signalData.functorCalled = true;
 231     return true;
 232   }
 233
 234   KeyEventGeneratedSignalData& signalData;
 235 };
 236
 237 void GenerateTouch( TestApplication& application, PointState::Type state, const Vector2& screenPosition )
 238 {
 239   Integration::TouchEvent touchEvent;
 240   Integration::Point point;
 241   point.SetState( state );
 242   point.SetScreenPosition( screenPosition );
 243   touchEvent.points.push_back( point );
 244   application.ProcessEvent( touchEvent );
 245 }
 246
 247 bool DummyTouchCallback( Actor actor, const TouchEvent& touch )
 248 {
 249   return true;
 250 }
 251
 252 void FrameCallback( int frameId )
 253 {
 254 }
 255
 256 } // unnamed namespace
 257
 258 int UtcDaliSceneAdd(void)
 259 {
 260   TestApplication application;
 261   tet_infoline("Testing Dali::Integration::Scene::Add");
 262
 263   Dali::Integration::Scene scene = application.GetScene();
 264
 265   Actor actor = Actor::New();
 266   DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
 267
 268   scene.Add( actor );
 269   DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
 270
 271   END_TEST;
 272 }
 273
 274 int UtcDaliSceneRemove(void)
 275 {
 276   TestApplication application;
 277   tet_infoline("Testing Dali::Integration::Scene::Remove");
 278
 279   Dali::Integration::Scene scene = application.GetScene();
 280
 281   Actor actor = Actor::New();
 282   DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
 283
 284   scene.Add( actor );
 285   DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
 286
 287   scene.Remove(actor);
 288   DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
 289
 290   END_TEST;
 291 }
 292
 293 int UtcDaliSceneGetSize(void)
 294 {
 295   TestApplication application;
 296   tet_infoline("Testing Dali::Integration::Scene::GetSize");
 297
 298   Dali::Integration::Scene scene = application.GetScene();
 299   Size size = scene.GetSize();
 300   DALI_TEST_EQUALS( TestApplication::DEFAULT_SURFACE_WIDTH, size.width, TEST_LOCATION );
 301   DALI_TEST_EQUALS( TestApplication::DEFAULT_SURFACE_HEIGHT, size.height, TEST_LOCATION );
 302
 303   END_TEST;
 304 }
 305
 306 int UtcDaliSceneGetDpi(void)
 307 {
 308   TestApplication application; // Initializes core DPI to default values
 309
 310   // Test that setting core DPI explicitly also sets up the scene's DPI.
 311   Dali::Integration::Scene scene = application.GetScene();
 312   scene.SetDpi( Vector2(200.0f, 180.0f) );
 313   Vector2 dpi = scene.GetDpi();
 314   DALI_TEST_EQUALS( dpi.x, 200.0f, TEST_LOCATION );
 315   DALI_TEST_EQUALS( dpi.y, 180.0f, TEST_LOCATION );
 316   END_TEST;
 317 }
 318
 319 int UtcDaliSceneGetRenderTaskList(void)
 320 {
 321   TestApplication application;
 322   tet_infoline("Testing Dali::Integration::Scene::GetRenderTaskList");
 323
 324   Dali::Integration::Scene scene = application.GetScene();
 325
 326   // Check we get a valid instance.
 327   const RenderTaskList& tasks = scene.GetRenderTaskList();
 328
 329   // There should be 1 task by default.
 330   DALI_TEST_EQUALS( tasks.GetTaskCount(), 1u, TEST_LOCATION );
 331
 332   // RenderTaskList has it's own UTC tests.
 333   // But we can confirm that GetRenderTaskList in Stage retrieves the same RenderTaskList each time.
 334   RenderTask newTask = scene.GetRenderTaskList().CreateTask();
 335
 336   DALI_TEST_EQUALS( scene.GetRenderTaskList().GetTask( 1 ), newTask, TEST_LOCATION );
 337
 338   END_TEST;
 339 }
 340
 341 int UtcDaliSceneGetRootLayer(void)
 342 {
 343   TestApplication application;
 344   tet_infoline("Testing Dali::Integration::Scene::GetRootLayer");
 345
 346   Dali::Integration::Scene scene = application.GetScene();
 347   Layer layer = scene.GetLayer( 0 );
 348   DALI_TEST_CHECK( layer );
 349
 350   // Check that GetRootLayer() correctly retreived layer 0.
 351   DALI_TEST_CHECK( scene.GetRootLayer() == layer );
 352
 353   END_TEST;
 354 }
 355
 356 int UtcDaliSceneGetLayerCount(void)
 357 {
 358   TestApplication application;
 359   tet_infoline("Testing Dali::Integration::Scene::GetLayerCount");
 360
 361   Dali::Integration::Scene scene = application.GetScene();
 362   // Initially we have a default layer
 363   DALI_TEST_EQUALS( scene.GetLayerCount(), 1u, TEST_LOCATION );
 364
 365   Layer layer = Layer::New();
 366   scene.Add( layer );
 367
 368   DALI_TEST_EQUALS( scene.GetLayerCount(), 2u, TEST_LOCATION );
 369   END_TEST;
 370 }
 371
 372 int UtcDaliSceneGetLayer(void)
 373 {
 374   TestApplication application;
 375   tet_infoline("Testing Dali::Integration::Scene::GetLayer");
 376
 377   Dali::Integration::Scene scene = application.GetScene();
 378
 379   Layer rootLayer = scene.GetLayer( 0 );
 380   DALI_TEST_CHECK( rootLayer );
 381
 382   Layer layer = Layer::New();
 383   scene.Add( layer );
 384
 385   Layer sameLayer = scene.GetLayer( 1 );
 386   DALI_TEST_CHECK( layer == sameLayer );
 387
 388   END_TEST;
 389 }
 390
 391 int UtcDaliSceneGet(void)
 392 {
 393   TestApplication application;
 394   tet_infoline("Testing Dali::Integration::Scene::Get");
 395
 396   Dali::Integration::Scene scene = application.GetScene();
 397
 398   Actor actor = Actor::New();
 399   DALI_TEST_CHECK( Dali::Integration::Scene() == Dali::Integration::Scene::Get( actor ) );
 400
 401   scene.Add( actor );
 402
 403   DALI_TEST_CHECK( scene == Dali::Integration::Scene::Get( actor ) );
 404
 405   END_TEST;
 406 }
 407
 408 int UtcDaliSceneDiscard(void)
 409 {
 410   TestApplication application;
 411   tet_infoline("Testing Dali::Scene::Discard");
 412
 413   // Create a new Scene
 414   Dali::Integration::Scene scene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) );
 415   DALI_TEST_CHECK( scene );
 416
 417   // One reference of scene kept here and the other one kept in the Core
 418   DALI_TEST_CHECK( scene.GetBaseObject().ReferenceCount() == 2 );
 419
 420   // Render and notify.
 421   application.SendNotification();
 422   application.Render(0);
 423
 424   // Keep the reference of the root layer handle so it will still be alive after the scene is deleted
 425   Layer rootLayer = scene.GetRootLayer();
 426   DALI_TEST_CHECK( rootLayer );
 427   DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 2 );
 428
 429   // Request to discard the scene from the Core
 430   scene.Discard();
 431   DALI_TEST_CHECK( scene.GetBaseObject().ReferenceCount() == 1 );
 432
 433   // Reset the scene handle
 434   scene.Reset();
 435
 436   // Render and notify.
 437   application.SendNotification();
 438   application.Render(0);
 439
 440   // At this point, the scene should have been automatically deleted
 441   // To prove this, the ref count of the root layer handle should be decremented to 1
 442   DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 1 );
 443
 444   // Delete the root layer handle
 445   rootLayer.Reset();
 446
 447   // Render and notify.
 448   application.SendNotification();
 449   application.Render(0);
 450
 451   END_TEST;
 452 }
 453
 454 int UtcDaliSceneCreateNewSceneDuringCoreEventProcessing(void)
 455 {
 456   TestApplication application;
 457
 458   Dali::Integration::Scene scene = application.GetScene();
 459
 460   TouchedSignalData data;
 461   data.createNewScene = true;
 462   TouchFunctor functor( data );
 463   scene.TouchSignal().Connect( &application, functor );
 464
 465   // Render and notify.
 466   application.SendNotification();
 467   application.Render();
 468
 469   GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
 470
 471   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 472   DALI_TEST_EQUALS( true, data.createNewScene, TEST_LOCATION );
 473   DALI_TEST_EQUALS( true, data.newSceneCreated, TEST_LOCATION );
 474   data.Reset();
 475
 476   END_TEST;
 477 }
 478
 479 int UtcDaliSceneRootLayerAndSceneAlignment(void)
 480 {
 481   TestApplication application;
 482
 483   // Create a Scene
 484   Dali::Integration::Scene scene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) );
 485   DALI_TEST_CHECK( scene );
 486
 487   // One reference of scene kept here and the other one kept in the Core
 488   DALI_TEST_CHECK( scene.GetBaseObject().ReferenceCount() == 2 );
 489
 490   // Add a renderable actor to the scene
 491   auto actor = CreateRenderableActor();
 492   scene.Add( actor );
 493
 494   // Render and notify.
 495   application.SendNotification();
 496   application.Render(0);
 497
 498   // Keep the reference of the root layer handle so it will still be alive after the scene is deleted
 499   Layer rootLayer = scene.GetRootLayer();
 500   DALI_TEST_CHECK( rootLayer );
 501   DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 2 );
 502
 503   // Request to discard the scene from the Core
 504   scene.Discard();
 505   DALI_TEST_CHECK( scene.GetBaseObject().ReferenceCount() == 1 );
 506
 507   // Reset the scene handle
 508   scene.Reset();
 509
 510   // Render and notify.
 511   application.SendNotification();
 512   application.Render(0);
 513
 514   // At this point, the scene should have been automatically deleted
 515   // To prove this, the ref count of the root layer handle should be decremented to 1
 516   DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 1 );
 517
 518   // Create a new Scene while the root layer of the deleted scene is still alive
 519   Dali::Integration::Scene newScene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) );
 520   DALI_TEST_CHECK( newScene );
 521
 522   // Render and notify.
 523   application.SendNotification();
 524   application.Render(0);
 525
 526   // At this point, we have only one scene but two root layers
 527   // The root layer of the deleted scene is still alive
 528   DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 1 );
 529
 530   // Delete the root layer of the deleted scene
 531   rootLayer.Reset();
 532
 533   // Render and notify.
 534   application.SendNotification();
 535   application.Render(0);
 536
 537   END_TEST;
 538 }
 539
 540 int UtcDaliSceneEventProcessingFinishedP(void)
 541 {
 542   TestApplication application;
 543   Dali::Integration::Scene scene = application.GetScene();
 544
 545   bool eventProcessingFinished = false;
 546   EventProcessingFinishedFunctor functor( eventProcessingFinished );
 547   scene.EventProcessingFinishedSignal().Connect( &application, functor );
 548
 549   Actor actor( Actor::New() );
 550   scene.Add( actor );
 551
 552   application.SendNotification();
 553   application.Render();
 554
 555   DALI_TEST_CHECK( eventProcessingFinished );
 556
 557   END_TEST;
 558 }
 559
 560 int UtcDaliSceneEventProcessingFinishedN(void)
 561 {
 562   TestApplication application;
 563   Dali::Integration::Scene scene = application.GetScene();
 564
 565   bool eventProcessingFinished = false;
 566   EventProcessingFinishedFunctor functor( eventProcessingFinished );
 567   scene.EventProcessingFinishedSignal().Connect( &application, functor );
 568
 569   Actor actor( Actor::New() );
 570   scene.Add( actor );
 571
 572   // Do not complete event processing and confirm the signal has not been emitted.
 573   DALI_TEST_CHECK( !eventProcessingFinished );
 574
 575   END_TEST;
 576 }
 577
 578 int UtcDaliSceneSignalKeyEventP(void)
 579 {
 580   TestApplication application;
 581   Dali::Integration::Scene scene = application.GetScene();
 582
 583   KeyEventSignalData data;
 584   KeyEventReceivedFunctor functor( data );
 585   scene.KeyEventSignal().Connect( &application, functor );
 586
 587   Integration::KeyEvent event( "i", "", "i", 0, 0, 0, Integration::KeyEvent::Down, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
 588   application.ProcessEvent( event );
 589
 590   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 591   DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier );
 592   DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName );
 593   DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed );
 594   DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
 595
 596   data.Reset();
 597
 598   Integration::KeyEvent event2( "i", "", "i", 0, 0, 0, Integration::KeyEvent::Up, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
 599   application.ProcessEvent( event2 );
 600
 601   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 602   DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier );
 603   DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName );
 604   DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed );
 605   DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
 606
 607   data.Reset();
 608
 609   Integration::KeyEvent event3( "a", "", "a", 0, 0, 0, Integration::KeyEvent::Down, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
 610   application.ProcessEvent( event3 );
 611
 612   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 613   DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier );
 614   DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName );
 615   DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed );
 616   DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
 617
 618   data.Reset();
 619
 620   Integration::KeyEvent event4( "a", "", "a", 0, 0, 0, Integration::KeyEvent::Up, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
 621   application.ProcessEvent( event4 );
 622
 623   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 624   DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier );
 625   DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName );
 626   DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed );
 627   DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
 628   END_TEST;
 629 }
 630
 631 int UtcDaliSceneSignalKeyEventN(void)
 632 {
 633   TestApplication application;
 634   Dali::Integration::Scene scene = application.GetScene();
 635
 636   KeyEventSignalData data;
 637   KeyEventReceivedFunctor functor( data );
 638   scene.KeyEventSignal().Connect( &application, functor );
 639
 640   // Check that a non-pressed key events data is not modified.
 641   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 642
 643   END_TEST;
 644 }
 645
 646 int UtcDaliSceneTouchSignalP(void)
 647 {
 648   TestApplication application;
 649   Dali::Integration::Scene scene = application.GetScene();
 650
 651   TouchedSignalData data;
 652   TouchFunctor functor( data );
 653   scene.TouchSignal().Connect( &application, functor );
 654
 655   // Render and notify.
 656   application.SendNotification();
 657   application.Render();
 658
 659   // Basic test: No actors, single touch (down then up).
 660   {
 661     GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
 662
 663     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 664     DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
 665     DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
 666     data.Reset();
 667
 668     GenerateTouch( application, PointState::UP, Vector2( 10.0f, 10.0f ) );
 669
 670     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 671     DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
 672     DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
 673     data.Reset();
 674   }
 675
 676   // Add an actor to the scene.
 677   Actor actor = Actor::New();
 678   actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
 679   actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
 680   actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
 681   actor.TouchedSignal().Connect( &DummyTouchCallback );
 682   scene.Add( actor );
 683
 684   // Render and notify.
 685   application.SendNotification();
 686   application.Render();
 687
 688   // Actor on scene, single touch, down in actor, motion, then up outside actor.
 689   {
 690     GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
 691
 692     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 693     DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
 694     DALI_TEST_CHECK( data.receivedTouchData.GetHitActor(0) == actor );
 695     data.Reset();
 696
 697     GenerateTouch( application, PointState::MOTION, Vector2( 150.0f, 10.0f ) ); // Some motion
 698
 699     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 700     data.Reset();
 701
 702     GenerateTouch( application, PointState::UP, Vector2( 150.0f, 10.0f ) ); // Some motion
 703
 704     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 705     DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
 706     DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
 707     data.Reset();
 708   }
 709
 710   // Multiple touch. Should only receive a touch on first down and last up.
 711   {
 712     Integration::TouchEvent touchEvent;
 713     Integration::Point point;
 714
 715     // 1st point
 716     point.SetState( PointState::DOWN );
 717     point.SetScreenPosition( Vector2( 10.0f, 10.0f ) );
 718     touchEvent.points.push_back( point );
 719     application.ProcessEvent( touchEvent );
 720     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 721     DALI_TEST_EQUALS( data.receivedTouchData.GetPointCount(), 1u, TEST_LOCATION );
 722     data.Reset();
 723
 724     // 2nd point
 725     touchEvent.points[0].SetState( PointState::STATIONARY );
 726     point.SetDeviceId( 1 );
 727     point.SetScreenPosition( Vector2( 50.0f, 50.0f ) );
 728     touchEvent.points.push_back( point );
 729     application.ProcessEvent( touchEvent );
 730     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 731     data.Reset();
 732
 733     // Primary point is up
 734     touchEvent.points[0].SetState( PointState::UP );
 735     touchEvent.points[1].SetState( PointState::STATIONARY );
 736     application.ProcessEvent( touchEvent );
 737     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 738     data.Reset();
 739
 740     // Remove 1st point now, 2nd point is now in motion
 741     touchEvent.points.erase( touchEvent.points.begin() );
 742     touchEvent.points[0].SetState( PointState::MOTION );
 743     touchEvent.points[0].SetScreenPosition( Vector2( 150.0f, 50.0f ) );
 744     application.ProcessEvent( touchEvent );
 745     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 746     data.Reset();
 747
 748     // Final point Up
 749     touchEvent.points[0].SetState( PointState::UP );
 750     application.ProcessEvent( touchEvent );
 751     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 752     DALI_TEST_EQUALS( data.receivedTouchData.GetPointCount(), 1u, TEST_LOCATION );
 753     data.Reset();
 754   }
 755   END_TEST;
 756 }
 757
 758 int UtcDaliSceneTouchSignalN(void)
 759 {
 760   TestApplication application;
 761   Dali::Integration::Scene scene = application.GetScene();
 762
 763   TouchedSignalData data;
 764   TouchFunctor functor( data );
 765   scene.TouchSignal().Connect( &application, functor );
 766
 767   // Render and notify.
 768   application.SendNotification();
 769   application.Render();
 770
 771   // Confirm functor not called before there has been any touch event.
 772   DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 773
 774   // No actors, single touch, down, motion then up.
 775   {
 776     GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
 777
 778     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 779     DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
 780     DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0));
 781
 782     data.Reset();
 783
 784     // Confirm there is no signal when the touchpoint is only moved.
 785     GenerateTouch( application, PointState::MOTION, Vector2( 1200.0f, 10.0f ) ); // Some motion
 786
 787     DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
 788     data.Reset();
 789
 790     // Confirm a following up event generates a signal.
 791     GenerateTouch( application, PointState::UP, Vector2( 1200.0f, 10.0f ) );
 792
 793     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 794     DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
 795     DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0));
 796     data.Reset();
 797   }
 798
 799   // Add an actor to the scene.
 800   Actor actor = Actor::New();
 801   actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
 802   actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
 803   actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
 804   actor.TouchedSignal().Connect( &DummyTouchCallback );
 805   scene.Add( actor );
 806
 807   // Render and notify.
 808   application.SendNotification();
 809   application.Render();
 810
 811   // Actor on scene. Interrupted before down and interrupted after down.
 812   {
 813     GenerateTouch( application, PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) );
 814
 815     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 816     DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
 817     DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
 818     DALI_TEST_CHECK( data.receivedTouchData.GetState(0) == PointState::INTERRUPTED );
 819     data.Reset();
 820
 821     GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
 822
 823     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 824     DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
 825     DALI_TEST_CHECK( data.receivedTouchData.GetHitActor(0) == actor );
 826     DALI_TEST_CHECK( data.receivedTouchData.GetState(0) == PointState::DOWN );
 827     data.Reset();
 828
 829     GenerateTouch( application, PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) );
 830
 831     DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 832     DALI_TEST_CHECK( data.receivedTouchData.GetPointCount() != 0u );
 833     DALI_TEST_CHECK( !data.receivedTouchData.GetHitActor(0) );
 834     DALI_TEST_CHECK( data.receivedTouchData.GetState(0) == PointState::INTERRUPTED );
 835
 836     DALI_TEST_EQUALS( data.receivedTouchData.GetPointCount(), 1u, TEST_LOCATION );
 837
 838     // Check that getting info about a non-existent point returns an empty handle
 839     Actor actor = data.receivedTouchData.GetHitActor( 1 );
 840     DALI_TEST_CHECK( !actor );
 841
 842     data.Reset();
 843   }
 844
 845   END_TEST;
 846 }
 847
 848 int UtcDaliSceneSignalWheelEventP(void)
 849 {
 850   TestApplication application;
 851   Dali::Integration::Scene scene = application.GetScene();
 852
 853   WheelEventSignalData data;
 854   WheelEventReceivedFunctor functor( data );
 855   scene.WheelEventSignal().Connect( &application, functor );
 856
 857   Integration::WheelEvent event( Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2( 0.0f, 0.0f ), 1, 1000u );
 858   application.ProcessEvent( event );
 859
 860   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 861   DALI_TEST_CHECK( static_cast< WheelEvent::Type >(event.type) == data.receivedWheelEvent.type );
 862   DALI_TEST_CHECK( event.direction == data.receivedWheelEvent.direction );
 863   DALI_TEST_CHECK( event.modifiers == data.receivedWheelEvent.modifiers );
 864   DALI_TEST_CHECK( event.point == data.receivedWheelEvent.point );
 865   DALI_TEST_CHECK( event.z == data.receivedWheelEvent.z );
 866   DALI_TEST_CHECK( event.timeStamp == data.receivedWheelEvent.timeStamp );
 867
 868   data.Reset();
 869
 870   Integration::WheelEvent event2( Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2( 0.0f, 0.0f ), -1, 1000u );
 871   application.ProcessEvent( event2 );
 872
 873   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
 874   DALI_TEST_CHECK( static_cast< WheelEvent::Type >(event2.type) == data.receivedWheelEvent.type );
 875   DALI_TEST_CHECK( event2.direction == data.receivedWheelEvent.direction );
 876   DALI_TEST_CHECK( event2.modifiers == data.receivedWheelEvent.modifiers );
 877   DALI_TEST_CHECK( event2.point == data.receivedWheelEvent.point );
 878   DALI_TEST_CHECK( event2.z == data.receivedWheelEvent.z );
 879   DALI_TEST_CHECK( event2.timeStamp == data.receivedWheelEvent.timeStamp );
 880   END_TEST;
 881 }
 882
 883 int UtcDaliSceneSurfaceResizedDefaultScene(void)
 884 {
 885   tet_infoline( "Ensure resizing of the surface is handled properly" );
 886
 887   TestApplication application;
 888
 889   auto defaultScene = application.GetScene();
 890   DALI_TEST_CHECK( defaultScene );
 891
 892   // Ensure stage size matches the scene size
 893   auto stage = Stage::GetCurrent();
 894   DALI_TEST_EQUALS( stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION );
 895
 896   // Resize the scene
 897   Vector2 newSize( 1000.0f, 2000.0f );
 898   DALI_TEST_CHECK( stage.GetSize() != newSize );
 899   defaultScene.SurfaceResized( newSize.width, newSize.height );
 900
 901   DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION );
 902   DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION );
 903
 904   END_TEST;
 905 }
 906
 907 int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void)
 908 {
 909   tet_infoline( "Ensure resizing of the surface & viewport is handled properly" );
 910
 911   TestApplication application;
 912   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 913   TraceCallStack& callStack = glAbstraction.GetViewportTrace();
 914   glAbstraction.EnableViewportCallTrace( true );
 915
 916   // Initial scene setup
 917   Geometry geometry = CreateQuadGeometry();
 918   Shader shader = CreateShader();
 919   Renderer renderer = Renderer::New( geometry, shader );
 920
 921   Actor actor = Actor::New();
 922   actor.AddRenderer(renderer);
 923   actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
 924   application.GetScene().Add(actor);
 925
 926   // Render before resizing surface
 927   application.SendNotification();
 928   application.Render(0);
 929   glAbstraction.ResetViewportCallStack();
 930
 931   auto defaultScene = application.GetScene();
 932   DALI_TEST_CHECK( defaultScene );
 933
 934   // Ensure stage size matches the scene size
 935   auto stage = Stage::GetCurrent();
 936   DALI_TEST_EQUALS( stage.GetSize(), defaultScene.GetSize(), 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   // Render after resizing surface
 948   application.SendNotification();
 949   application.Render(0);
 950
 951   // Check that the viewport is handled properly
 952   DALI_TEST_CHECK( callStack.FindMethodAndGetParameters("Viewport", viewportParams ) );
 953
 954   END_TEST;
 955 }
 956
 957 int UtcDaliSceneSurfaceResizedMultipleRenderTasks(void)
 958 {
 959   tet_infoline( "Ensure resizing of the surface & viewport is handled properly" );
 960
 961   TestApplication application;
 962   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 963   TraceCallStack& callStack = glAbstraction.GetViewportTrace();
 964   glAbstraction.EnableViewportCallTrace( true );
 965
 966   // Initial scene setup
 967   auto scene = application.GetScene();
 968
 969   Geometry geometry = CreateQuadGeometry();
 970   Shader shader = CreateShader();
 971   Renderer renderer = Renderer::New( geometry, shader );
 972
 973   Actor actor = Actor::New();
 974   actor.AddRenderer(renderer);
 975   int testWidth = 400;
 976   int testHeight = 400;
 977   actor.SetProperty( Actor::Property::SIZE, Vector2( testWidth, testHeight) );
 978   scene.Add(actor);
 979
 980   CameraActor offscreenCameraActor = CameraActor::New( Size( testWidth, testHeight ) );
 981   application.GetScene().Add( offscreenCameraActor );
 982
 983   FrameBuffer newFrameBuffer = FrameBuffer::New( testWidth, testHeight, FrameBuffer::Attachment::NONE );
 984
 985   RenderTask newTask = scene.GetRenderTaskList().CreateTask();
 986   newTask.SetCameraActor( offscreenCameraActor );
 987   newTask.SetSourceActor( actor );
 988   newTask.SetFrameBuffer( newFrameBuffer );
 989   newTask.SetViewportPosition( Vector2(0, 0) );
 990   newTask.SetViewportSize( Vector2(testWidth, testHeight) );
 991
 992   // Render before resizing surface
 993   application.SendNotification();
 994   application.Render(0);
 995   glAbstraction.ResetViewportCallStack();
 996
 997   Rect<int32_t> initialViewport = newTask.GetViewport();
 998   int initialWidth = initialViewport.width;
 999   int initialHeight = initialViewport.height;
1000   DALI_TEST_EQUALS( initialWidth, testWidth, TEST_LOCATION );
1001   DALI_TEST_EQUALS( initialHeight, testHeight, TEST_LOCATION );
1002
1003   auto defaultScene = application.GetScene();
1004   DALI_TEST_CHECK( defaultScene );
1005
1006   // Ensure stage size matches the scene size
1007   auto stage = Stage::GetCurrent();
1008   DALI_TEST_EQUALS( stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION );
1009
1010   // Resize the scene
1011   Vector2 newSize( 1000.0f, 2000.0f );
1012   std::string viewportParams( "0, 0, 1000, 2000" ); // to match newSize
1013   DALI_TEST_CHECK( stage.GetSize() != newSize );
1014   defaultScene.SurfaceResized( newSize.width, newSize.height );
1015
1016   DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION );
1017   DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION );
1018
1019   // Render after resizing surface
1020   application.SendNotification();
1021   application.Render(0);
1022
1023   // Check that the viewport is handled properly
1024   DALI_TEST_CHECK( callStack.FindMethodAndGetParameters("Viewport", viewportParams ) );
1025
1026   // Second render-task should not be affected
1027   Rect<int32_t> viewport = newTask.GetViewport();
1028   int width = viewport.width;
1029   int height = viewport.height;
1030   DALI_TEST_EQUALS( width, testWidth, TEST_LOCATION );
1031   DALI_TEST_EQUALS( height, testHeight, TEST_LOCATION );
1032
1033   END_TEST;
1034 }
1035
1036 int UtcDaliSceneSurfaceResizedAdditionalScene(void)
1037 {
1038   tet_infoline( "Ensure resizing of the surface is handled properly on additional scenes" );
1039
1040   TestApplication application;
1041   Vector2 originalSurfaceSize( 500.0f, 1000.0f );
1042
1043   auto scene = Integration::Scene::New( Size( originalSurfaceSize.width, originalSurfaceSize.height ) );
1044
1045   // Ensure stage size does NOT match the surface size
1046   auto stage = Stage::GetCurrent();
1047   const auto stageSize = stage.GetSize();
1048   DALI_TEST_CHECK( stageSize != originalSurfaceSize );
1049   DALI_TEST_EQUALS( originalSurfaceSize, scene.GetSize(), TEST_LOCATION );
1050
1051   // Resize the surface and inform the scene accordingly
1052   Vector2 newSize( 1000.0f, 2000.0f );
1053   DALI_TEST_CHECK( stage.GetSize() != newSize );
1054   scene.SurfaceResized( newSize.width, newSize.height );
1055
1056   // Ensure the stage hasn't been resized
1057   DALI_TEST_EQUALS( stage.GetSize(), stageSize, TEST_LOCATION );
1058   DALI_TEST_EQUALS( scene.GetSize(), newSize, TEST_LOCATION );
1059
1060   END_TEST;
1061 }
1062
1063 int UtcDaliSceneKeyEventGeneratedSignalP(void)
1064 {
1065   TestApplication application;
1066   Dali::Integration::Scene scene = application.GetScene();
1067
1068   KeyEventGeneratedSignalData data;
1069   KeyEventGeneratedReceivedFunctor functor( data );
1070   scene.KeyEventGeneratedSignal().Connect( &application, functor );
1071
1072   Integration::KeyEvent event( "a", "", "a", 0, 0, 0, Integration::KeyEvent::Up, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
1073   application.ProcessEvent( event );
1074
1075   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1076   DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.keyModifier );
1077   DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.keyPressedName );
1078   DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.keyPressed );
1079   DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
1080
1081   data.Reset();
1082
1083   Integration::KeyEvent event2( "i", "", "i", 0, 0, 0, Integration::KeyEvent::Up, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
1084   application.ProcessEvent( event2 );
1085
1086   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1087   DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.keyModifier );
1088   DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.keyPressedName );
1089   DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.keyPressed );
1090   DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
1091
1092   data.Reset();
1093
1094   Integration::KeyEvent event3( "a", "", "a", 0, 0, 0, Integration::KeyEvent::Down, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
1095   application.ProcessEvent( event3 );
1096
1097   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1098   DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.keyModifier );
1099   DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.keyPressedName );
1100   DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.keyPressed );
1101   DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
1102
1103   data.Reset();
1104
1105   Integration::KeyEvent event4( "a", "", "a", 0, 0, 0, Integration::KeyEvent::Up, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
1106   application.ProcessEvent( event4 );
1107
1108   DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
1109   DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.keyModifier );
1110   DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.keyPressedName );
1111   DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.keyPressed );
1112   DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.state ) );
1113   END_TEST;
1114 }
1115
1116 int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void)
1117 {
1118   tet_infoline( "Ensure we keep background color when the scene surface is replaced " );
1119
1120   TestApplication application;
1121
1122   // Create a new scene and set the background color of the main scene
1123   auto defaultScene = application.GetScene();
1124   defaultScene.SetBackgroundColor( Color::BLUE );
1125
1126   // Need to create a renderable as we don't start rendering until we have at least one
1127   // We don't need to add this to any scene
1128   auto actor = CreateRenderableActor();
1129
1130   auto& glAbstraction = application.GetGlAbstraction();
1131   auto clearCountBefore = glAbstraction.GetClearCountCalled();
1132
1133   application.SendNotification();
1134   application.Render();
1135
1136   DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
1137   DALI_TEST_EQUALS( glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION );
1138
1139   defaultScene.SurfaceReplaced();
1140
1141   application.SendNotification();
1142   application.Render();
1143
1144   DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION );
1145   DALI_TEST_EQUALS( glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION );
1146
1147   // Check when the main render task viewport is set the clear color is clipped using scissors
1148   TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
1149   TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
1150   scissorTrace.Enable( true );
1151   enabledDisableTrace.Enable( true );
1152
1153   defaultScene.GetRenderTaskList().GetTask( 0 ).SetViewport( Viewport( 0.0f, 0.0f, 100.0f, 100.0f ) );
1154
1155   application.SendNotification();
1156   application.Render();
1157
1158   // Check scissor test was enabled.
1159   DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
1160
1161   // Check the scissor was set, and the coordinates are correct.
1162   DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", "0, 700, 100, 100" ) );
1163
1164   DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION );
1165   DALI_TEST_EQUALS( glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION );
1166
1167   scissorTrace.Enable( false );
1168   scissorTrace.Reset();
1169
1170   enabledDisableTrace.Enable( false );
1171   enabledDisableTrace.Reset();
1172
1173   END_TEST;
1174 }
1175
1176 int UtcDaliSceneEmptySceneRendering(void)
1177 {
1178   tet_infoline( "Ensure not rendering before a Renderer is added" );
1179
1180   TestApplication application;
1181   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1182
1183   // Render without any renderer
1184   application.SendNotification();
1185   application.Render();
1186
1187   // Check the clear count and the render status
1188   DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), 0, TEST_LOCATION );
1189   DALI_TEST_EQUALS( application.GetRenderNeedsPostRender(), false, TEST_LOCATION );
1190
1191   // Add a Renderer
1192   Geometry geometry = CreateQuadGeometry();
1193   Shader shader = CreateShader();
1194   Renderer renderer = Renderer::New( geometry, shader );
1195
1196   Actor actor = Actor::New();
1197   actor.AddRenderer( renderer );
1198
1199   actor.SetProperty( Actor::Property::SIZE, Vector2( 400, 400 ) );
1200   application.GetScene().Add( actor );
1201
1202   // Render
1203   application.SendNotification();
1204   application.Render();
1205
1206   // Check the clear count and the render status
1207   DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), 1, TEST_LOCATION );
1208   DALI_TEST_EQUALS( application.GetRenderNeedsPostRender(), true, TEST_LOCATION );
1209
1210   // Remove the Renderer
1211   application.GetScene().Remove( actor );
1212   actor.Reset();
1213   renderer.Reset();
1214
1215   // Render
1216   application.SendNotification();
1217   application.Render();
1218
1219   // Check the clear count and the render status
1220   DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), 2, TEST_LOCATION );  // Should be cleared
1221   DALI_TEST_EQUALS( application.GetRenderNeedsPostRender(), true, TEST_LOCATION );
1222
1223   END_TEST;
1224 }
1225
1226 int UtcDaliSceneFrameRenderedPresentedCallback(void)
1227 {
1228   tet_infoline( "UtcDaliSceneFrameRenderedCallback" );
1229
1230   TestApplication application;
1231
1232   // Add a Renderer
1233   Geometry geometry = CreateQuadGeometry();
1234   Shader shader = CreateShader();
1235   Renderer renderer = Renderer::New( geometry, shader );
1236
1237   Actor actor = Actor::New();
1238   actor.AddRenderer( renderer );
1239   application.GetScene().Add( actor );
1240
1241   Dali::Integration::Scene scene = application.GetScene();
1242
1243   int frameId = 1;
1244   scene.AddFrameRenderedCallback( std::unique_ptr< CallbackBase >( MakeCallback( &FrameCallback ) ), frameId );
1245   scene.AddFramePresentedCallback( std::unique_ptr< CallbackBase >( MakeCallback( &FrameCallback ) ), frameId );
1246
1247   // Render
1248   application.SendNotification();
1249   application.Render();
1250
1251   Dali::Integration::Scene::FrameCallbackContainer callbackContainer;
1252   scene.GetFrameRenderedCallback( callbackContainer );
1253
1254   DALI_TEST_EQUALS( callbackContainer.size(), 1, TEST_LOCATION );
1255   DALI_TEST_EQUALS( callbackContainer[0].second, frameId, TEST_LOCATION );
1256
1257   callbackContainer.clear();
1258
1259   scene.GetFramePresentedCallback( callbackContainer );
1260
1261   DALI_TEST_EQUALS( callbackContainer.size(), 1, TEST_LOCATION );
1262   DALI_TEST_EQUALS( callbackContainer[0].second, frameId, TEST_LOCATION );
1263
1264   END_TEST;
1265 }