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

   1 /*
   2  * Copyright (c) 2014 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/public-api/dali-core.h>
  22 #include <dali-test-suite-utils.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <test-native-image.h>
  25
  26 #define BOOLSTR(x) ((x)?"T":"F")
  27
  28
  29 using namespace Dali;
  30
  31 void utc_dali_render_task_startup(void)
  32 {
  33   test_return_value = TET_UNDEF;
  34 }
  35
  36 void utc_dali_render_task_cleanup(void)
  37 {
  38   test_return_value = TET_PASS;
  39 }
  40
  41 namespace // unnamed namespace
  42 {
  43
  44 const int RENDER_FRAME_INTERVAL = 16;                           ///< Duration of each frame in ms. (at approx 60FPS)
  45
  46 /*
  47  * Simulate time passed by.
  48  *
  49  * @note this will always process at least 1 frame (1/60 sec)
  50  *
  51  * @param application Test application instance
  52  * @param duration Time to pass in milliseconds.
  53  * @return The actual time passed in milliseconds
  54  */
  55 int Wait(TestApplication& application, int duration = 0)
  56 {
  57   int time = 0;
  58
  59   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
  60   {
  61     application.SendNotification();
  62     application.Render(RENDER_FRAME_INTERVAL);
  63     time += RENDER_FRAME_INTERVAL;
  64   }
  65
  66   return time;
  67 }
  68
  69 struct RenderTaskFinished
  70 {
  71   RenderTaskFinished( bool& finished )
  72   : finished( finished )
  73   {
  74   }
  75
  76   void operator()( RenderTask& renderTask )
  77   {
  78     finished = true;
  79   }
  80
  81   bool& finished;
  82 };
  83
  84 struct RenderTaskFinishedRemoveSource
  85 {
  86   RenderTaskFinishedRemoveSource( bool& finished )
  87   : finished( finished ),
  88     finishedOnce(false)
  89   {
  90   }
  91
  92   void operator()( RenderTask& renderTask )
  93   {
  94     DALI_TEST_CHECK(finishedOnce == false);
  95     finished = true;
  96     finishedOnce = true;
  97     Actor srcActor = renderTask.GetSourceActor();
  98     UnparentAndReset(srcActor);
  99   }
 100
 101   bool& finished;
 102   bool finishedOnce;
 103 };
 104
 105 struct RenderTaskFinishedRenderAgain
 106 {
 107   RenderTaskFinishedRenderAgain( bool& finished )
 108   : finished( finished ),
 109     finishedOnce(false)
 110   {
 111   }
 112
 113   void operator()( RenderTask& renderTask )
 114   {
 115     DALI_TEST_CHECK(finishedOnce == false);
 116     finished = true;
 117     finishedOnce = true;
 118     renderTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
 119   }
 120
 121   bool& finished;
 122   bool finishedOnce;
 123 };
 124
 125
 126 bool TestScreenToFrameBufferFunction( Vector2& coordinates )
 127 {
 128   coordinates = coordinates + Vector2( 1, 2 );
 129
 130   return true;
 131 }
 132
 133 ImageActor CreateLoadingImage(TestApplication& application, std::string filename, ResourceImage::LoadPolicy loadPolicy, Image::ReleasePolicy releasePolicy)
 134 {
 135   Image image = ResourceImage::New(filename, loadPolicy, releasePolicy);
 136   DALI_TEST_CHECK( image );
 137   application.SendNotification();
 138   application.Render(16);
 139   DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
 140   ImageActor actor = ImageActor::New(image);
 141   actor.SetSize( 80, 80 );
 142   application.SendNotification();
 143   application.Render(16);
 144   return actor;
 145 }
 146
 147 void CompleteImageLoad(TestApplication& application, Integration::ResourceId resourceId, Integration::ResourceTypeId requestType)
 148 {
 149   std::vector<GLuint> ids;
 150   ids.push_back( 23 );
 151   application.GetGlAbstraction().SetNextTextureIds( ids );
 152
 153   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::DISCARD );
 154   Integration::ResourcePointer resource(bitmap);
 155   bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
 156
 157   application.GetPlatform().SetResourceLoaded(resourceId, requestType, resource);
 158 }
 159
 160 void FailImageLoad(TestApplication& application, Integration::ResourceId resourceId )
 161 {
 162   application.GetPlatform().SetResourceLoadFailed(resourceId, Integration::FailureUnknown);
 163 }
 164
 165 void ReloadImage(TestApplication& application, ResourceImage image)
 166 {
 167   application.GetPlatform().ClearReadyResources();
 168   application.GetPlatform().DiscardRequest();
 169   application.GetPlatform().ResetTrace();
 170   application.GetPlatform().SetClosestImageSize(Vector2(80.0f, 80.0f)); // Ensure reload is called.
 171   image.Reload();
 172 }
 173
 174 RenderTask CreateRenderTask(TestApplication& application,
 175                             CameraActor offscreenCamera,
 176                             Actor rootActor,       // Reset default render task to point at this actor
 177                             Actor secondRootActor, // Source actor
 178                             unsigned int refreshRate,
 179                             bool glSync)
 180 {
 181   // Change main render task to use a different root
 182   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 183   taskList.GetTask(0u).SetSourceActor( rootActor );
 184
 185   FrameBufferImage frameBufferImage;
 186   if( glSync )
 187   {
 188     NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
 189     frameBufferImage= FrameBufferImage::New( *(testNativeImagePtr.Get()) );
 190   }
 191   else
 192   {
 193     frameBufferImage = FrameBufferImage::New( 10, 10 );
 194   }
 195
 196   // Don't draw output framebuffer
 197
 198   RenderTask newTask = taskList.CreateTask();
 199   newTask.SetCameraActor( offscreenCamera );
 200   newTask.SetSourceActor( secondRootActor );
 201   newTask.SetInputEnabled( false );
 202   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
 203   newTask.SetClearEnabled( true );
 204   newTask.SetExclusive( true );
 205   newTask.SetRefreshRate( refreshRate );
 206   newTask.SetTargetFrameBuffer( frameBufferImage );
 207   return newTask;
 208 }
 209
 210 bool UpdateRender(TestApplication& application, TraceCallStack& callStack, bool testDrawn, bool& finishedSig, bool testFinished, bool testKeepUpdating )
 211 {
 212   finishedSig = false;
 213   callStack.Reset();
 214   application.Render(16);
 215   application.SendNotification();
 216
 217   bool sigPassed = false;
 218   if( testFinished )
 219   {
 220     sigPassed = finishedSig;
 221   }
 222   else
 223   {
 224     sigPassed = ! finishedSig;
 225   }
 226
 227   bool drawResult = callStack.FindMethod("DrawElements") || callStack.FindMethod("DrawArrays");
 228
 229   bool drawPassed = false;
 230   if( testDrawn )
 231   {
 232     drawPassed = drawResult;
 233   }
 234   else
 235   {
 236     drawPassed = !drawResult;
 237   }
 238
 239   bool keepUpdating = (application.GetUpdateStatus() != 0);
 240   bool keepUpdatingPassed = false;
 241   if( testKeepUpdating )
 242   {
 243     keepUpdatingPassed = keepUpdating;
 244   }
 245   else
 246   {
 247     keepUpdatingPassed = !keepUpdating;
 248   }
 249
 250   bool result = (sigPassed && drawPassed && keepUpdatingPassed);
 251
 252   tet_printf("UpdateRender: Expected: Draw:%s Signal:%s Keep Updating: %s  Actual: Draw:%s  Signal:%s KeepUpdating: %s  %s\n",
 253              BOOLSTR(testDrawn), BOOLSTR(testFinished), BOOLSTR(testKeepUpdating),
 254              BOOLSTR(drawResult), BOOLSTR(finishedSig), BOOLSTR(keepUpdating),
 255              result ? "Passed":"Failed");
 256
 257   return result;
 258 }
 259
 260 // The functor to be used in the hit-test algorithm to check whether the actor is hittable.
 261 bool IsActorHittableFunction(Actor actor, Dali::HitTestAlgorithm::TraverseType type)
 262 {
 263   bool hittable = false;
 264
 265   switch (type)
 266   {
 267     case Dali::HitTestAlgorithm::CHECK_ACTOR:
 268     {
 269       // Check whether the actor is visible and not fully transparent.
 270       if( actor.IsVisible()
 271        && actor.GetCurrentWorldColor().a > 0.01f) // not FULLY_TRANSPARENT
 272       {
 273
 274           hittable = true;
 275       }
 276       break;
 277     }
 278     case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
 279     {
 280       if( actor.IsVisible() ) // Actor is visible, if not visible then none of its children are visible.
 281       {
 282         hittable = true;
 283       }
 284       break;
 285     }
 286     default:
 287     {
 288       break;
 289     }
 290   }
 291
 292   return hittable;
 293 }
 294
 295 } // unnamed namespace
 296
 297
 298 /****************************************************************************************************/
 299 /****************************************************************************************************/
 300 /********************************   TEST CASES BELOW   **********************************************/
 301 /****************************************************************************************************/
 302 /****************************************************************************************************/
 303
 304 int UtcDaliRenderTaskDownCast(void)
 305 {
 306   TestApplication application;
 307
 308   tet_infoline("Testing RenderTask::DownCast()");
 309
 310   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 311
 312   BaseHandle base = taskList.GetTask( 0u );
 313   DALI_TEST_CHECK( base );
 314
 315   RenderTask task = RenderTask::DownCast( base );
 316   DALI_TEST_CHECK( task );
 317
 318   // Try calling a method
 319   DALI_TEST_CHECK( task.GetSourceActor() );
 320   END_TEST;
 321 }
 322
 323 int UtcDaliRenderTaskSetSourceActor(void)
 324 {
 325   TestApplication application;
 326
 327   tet_infoline("Testing RenderTask::SetSourceActor()");
 328
 329   Stage stage = Stage::GetCurrent();
 330
 331   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 332
 333   RenderTaskList taskList = stage.GetRenderTaskList();
 334
 335   RenderTask task = taskList.GetTask( 0u );
 336
 337   Actor actor = task.GetSourceActor();
 338   DALI_TEST_CHECK( actor );
 339
 340   std::vector<GLuint> ids;
 341   ids.push_back( 7 );
 342   application.GetGlAbstraction().SetNextTextureIds( ids );
 343
 344   BufferImage img = BufferImage::New( 1,1 );
 345   ImageActor newActor = ImageActor::New( img );
 346   newActor.SetSize(1,1);
 347   stage.Add( newActor );
 348
 349   Actor nonRenderableActor = Actor::New();
 350   stage.Add( nonRenderableActor );
 351
 352   // Stop the newActor from being rendered by changing the source actor
 353   DALI_TEST_CHECK( nonRenderableActor );
 354   task.SetSourceActor( nonRenderableActor );
 355   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 356   DALI_TEST_CHECK( task.GetSourceActor() == nonRenderableActor );
 357
 358   // Update & Render nothing!
 359   application.GetGlAbstraction().ClearBoundTextures();
 360   application.SendNotification();
 361   application.Render();
 362
 363   // Check that nothing was rendered
 364   DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
 365
 366   // Set newActor as the new source Actor
 367   task.SetSourceActor( newActor );
 368   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 369   DALI_TEST_CHECK( task.GetSourceActor() == newActor );
 370
 371   // Update & Render the newActor
 372   application.GetGlAbstraction().ClearBoundTextures();
 373   application.SendNotification();
 374   application.Render();
 375
 376   // Check that the newActor was rendered
 377   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 378   if ( boundTextures.size() )
 379   {
 380     DALI_TEST_EQUALS( boundTextures[0], 7u, TEST_LOCATION );
 381   }
 382   END_TEST;
 383 }
 384
 385 int UtcDaliRenderTaskSetSourceActorOffStage(void)
 386 {
 387   TestApplication application;
 388
 389   tet_infoline("Testing RenderTask::SetSourceActor (on/off stage testing)");
 390
 391   Stage stage = Stage::GetCurrent();
 392
 393   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 394
 395   RenderTaskList taskList = stage.GetRenderTaskList();
 396
 397   RenderTask task = taskList.GetTask( 0u );
 398
 399   Actor actor = task.GetSourceActor();
 400   DALI_TEST_CHECK( actor );
 401
 402   std::vector<GLuint> ids;
 403   GLuint expectedTextureId( 3 );
 404   ids.push_back( expectedTextureId );
 405   application.GetGlAbstraction().SetNextTextureIds( ids );
 406
 407   BufferImage img = BufferImage::New( 1,1 );
 408   ImageActor newActor = ImageActor::New( img );
 409   newActor.SetSize(1,1);
 410   task.SetSourceActor( newActor );
 411   // Don't add newActor to stage yet
 412
 413   // Update & Render with the actor initially off-stage
 414   application.GetGlAbstraction().ClearBoundTextures();
 415   application.SendNotification();
 416   application.Render();
 417
 418   // Check that nothing was rendered
 419   DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
 420
 421   // Now add to stage
 422   stage.Add( newActor );
 423
 424   // Update & Render with the actor on-stage
 425   application.GetGlAbstraction().ClearBoundTextures();
 426   application.SendNotification();
 427   application.Render();
 428
 429   // Check that the newActor was rendered
 430   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 431   if ( boundTextures.size() )
 432   {
 433     DALI_TEST_EQUALS( boundTextures[0], expectedTextureId, TEST_LOCATION );
 434   }
 435
 436   // Now remove from stage
 437   stage.Remove( newActor );
 438
 439   // Update & Render with the actor off-stage
 440   application.GetGlAbstraction().ClearBoundTextures();
 441   application.SendNotification();
 442   application.Render();
 443   END_TEST;
 444 }
 445
 446 int UtcDaliRenderTaskSetSourceActorEmpty(void)
 447 {
 448   TestApplication application;
 449
 450   tet_infoline("Testing RenderTask::SetSourceActor (empty handle case)");
 451
 452   Stage stage = Stage::GetCurrent();
 453
 454   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 455
 456   RenderTaskList taskList = stage.GetRenderTaskList();
 457
 458   RenderTask task = taskList.GetTask( 0u );
 459
 460   Actor actor = task.GetSourceActor();
 461   DALI_TEST_CHECK( actor );
 462
 463   std::vector<GLuint> ids;
 464   GLuint expectedTextureId( 5 );
 465   ids.push_back( expectedTextureId );
 466   application.GetGlAbstraction().SetNextTextureIds( ids );
 467
 468   BufferImage img = BufferImage::New( 1,1 );
 469   ImageActor newActor = ImageActor::New( img );
 470   newActor.SetSize(1,1);
 471   stage.Add( newActor );
 472
 473   Actor nonRenderableActor = Actor::New();
 474   stage.Add( nonRenderableActor );
 475
 476   // Set with empty handle
 477   task.SetSourceActor( Actor() );
 478   DALI_TEST_CHECK( ! task.GetSourceActor() );
 479
 480   // Update & Render nothing!
 481   application.GetGlAbstraction().ClearBoundTextures();
 482   application.SendNotification();
 483   application.Render();
 484
 485   // Check that nothing was rendered
 486   DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
 487
 488   // Set with non-empty handle
 489   task.SetSourceActor( newActor );
 490   DALI_TEST_CHECK( task.GetSourceActor() == newActor );
 491
 492   // Update & Render the newActor
 493   application.GetGlAbstraction().ClearBoundTextures();
 494   application.SendNotification();
 495   application.Render();
 496
 497   // Check that the newActor was rendered
 498   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 499   if ( boundTextures.size() )
 500   {
 501     DALI_TEST_EQUALS( boundTextures[0], expectedTextureId, TEST_LOCATION );
 502   }
 503   END_TEST;
 504 }
 505
 506 int UtcDaliRenderTaskGetSourceActor(void)
 507 {
 508   TestApplication application;
 509
 510   tet_infoline("Testing RenderTask::GetSourceActor()");
 511
 512   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 513
 514   RenderTask task = taskList.GetTask( 0u );
 515
 516   Actor actor = task.GetSourceActor();
 517   DALI_TEST_CHECK( actor );
 518
 519   // By default the entire scene should be rendered
 520   Actor root = Stage::GetCurrent().GetLayer( 0 );
 521   DALI_TEST_CHECK( root == actor );
 522   END_TEST;
 523 }
 524
 525 int UtcDaliRenderTaskSetExclusive(void)
 526 {
 527   TestApplication application;
 528
 529   tet_infoline("Testing RenderTask::SetExclusive()");
 530
 531   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 532
 533   // Manipulate the GenTextures behaviour, to identify different ImageActors
 534
 535   std::vector<GLuint> ids;
 536   ids.push_back( 8 ); // 8 = actor1
 537   ids.push_back( 9 ); // 9 = actor2
 538   ids.push_back( 10 ); // 10 = actor3
 539   application.GetGlAbstraction().SetNextTextureIds( ids );
 540
 541   BufferImage img1 = BufferImage::New( 1,1 );
 542   ImageActor actor1 = ImageActor::New( img1 );
 543   actor1.SetSize(1,1);
 544   Stage::GetCurrent().Add( actor1 );
 545
 546   // Update & Render actor1
 547   application.SendNotification();
 548   application.Render();
 549
 550   // Check that the actor1 was rendered
 551   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 552   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 553
 554   if ( boundTextures.size() )
 555   {
 556     DALI_TEST_EQUALS( boundTextures[0], 8u/*unique to actor1*/, TEST_LOCATION );
 557   }
 558
 559   BufferImage img2 = BufferImage::New( 1,1 );
 560   ImageActor actor2 = ImageActor::New( img2 );
 561   actor2.SetSize(1,1);
 562
 563   // Force actor2 to be rendered before actor1
 564   Layer layer = Layer::New();
 565   Stage::GetCurrent().Add( layer );
 566   layer.Add( actor2 );
 567   layer.LowerToBottom();
 568
 569   // Update & Render
 570   application.GetGlAbstraction().ClearBoundTextures();
 571   application.SendNotification();
 572   application.Render();
 573
 574   // Check that the actors were rendered
 575   DALI_TEST_EQUALS( boundTextures.size(), 2u, TEST_LOCATION );
 576
 577   if ( boundTextures.size() )
 578   {
 579     DALI_TEST_EQUALS( boundTextures[0], 9u/*unique to actor2*/, TEST_LOCATION );
 580     DALI_TEST_EQUALS( boundTextures[1], 8u/*unique to actor1*/, TEST_LOCATION );
 581   }
 582
 583   BufferImage img3 = BufferImage::New( 1,1 );
 584   ImageActor actor3 = ImageActor::New( img3 );
 585   actor3.SetSize(1,1);
 586
 587   // Force actor3 to be rendered before actor2
 588   layer = Layer::New();
 589   Stage::GetCurrent().Add( layer );
 590   layer.Add( actor3 );
 591   layer.LowerToBottom();
 592
 593   // Update & Render all actors
 594   application.GetGlAbstraction().ClearBoundTextures();
 595   application.SendNotification();
 596   application.Render();
 597
 598   // Check that the actors were rendered
 599   DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
 600
 601   if ( boundTextures.size() )
 602   {
 603     DALI_TEST_EQUALS( boundTextures[0], 10u/*unique to actor3*/, TEST_LOCATION );
 604     DALI_TEST_EQUALS( boundTextures[1], 9u/*unique to actor2*/, TEST_LOCATION );
 605     DALI_TEST_EQUALS( boundTextures[2], 8u/*unique to actor1*/, TEST_LOCATION );
 606   }
 607
 608   // Both actors are now connected to the root node
 609   // Setup 2 render-tasks - the first will render from the root-node, and the second from actor2
 610
 611   // Not exclusive is the default
 612   RenderTask task1 = taskList.GetTask( 0u );
 613   DALI_TEST_CHECK( false == task1.IsExclusive() );
 614
 615   RenderTask task2 = taskList.CreateTask();
 616   DALI_TEST_CHECK( false == task2.IsExclusive() );
 617   task2.SetSourceActor( actor2 );
 618
 619   // Task1 should render all actors, and task 2 should render only actor2
 620
 621   application.GetGlAbstraction().ClearBoundTextures();
 622   application.SendNotification();
 623   application.Render();
 624
 625   DALI_TEST_EQUALS( boundTextures.size(), 4u, TEST_LOCATION );
 626
 627   if ( boundTextures.size() == 4 )
 628   {
 629     // Test that task 1 renders actor3, then actor2 & then actor1
 630     DALI_TEST_CHECK( boundTextures[0] == 10u );
 631     DALI_TEST_CHECK( boundTextures[1] == 9u );
 632     DALI_TEST_CHECK( boundTextures[2] == 8u );
 633
 634     // Test that task 2 renders actor2
 635     DALI_TEST_EQUALS( boundTextures[3], 9u, TEST_LOCATION );
 636   }
 637
 638   // Make actor2 exclusive to task2
 639
 640   task2.SetExclusive( true );
 641   DALI_TEST_CHECK( true == task2.IsExclusive() );
 642
 643   // Task1 should render only actor1, and task 2 should render only actor2
 644
 645   application.GetGlAbstraction().ClearBoundTextures();
 646   application.SendNotification();
 647   application.Render();
 648
 649   DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
 650   if ( boundTextures.size() == 3 )
 651   {
 652     // Test that task 1 renders actor3 & actor1
 653     DALI_TEST_CHECK( boundTextures[0] == 10u );
 654     DALI_TEST_CHECK( boundTextures[1] == 8u );
 655
 656     // Test that task 2 renders actor2
 657     DALI_TEST_CHECK( boundTextures[2] == 9u );
 658   }
 659   END_TEST;
 660 }
 661
 662 int UtcDaliRenderTaskIsExclusive(void)
 663 {
 664   TestApplication application;
 665
 666   tet_infoline("Testing RenderTask::IsExclusive()");
 667
 668   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 669
 670   // Not exclusive is the default
 671   RenderTask task = taskList.GetTask( 0u );
 672   DALI_TEST_CHECK( false == task.IsExclusive() );
 673
 674   RenderTask newTask = taskList.CreateTask();
 675   DALI_TEST_CHECK( false == newTask.IsExclusive() );
 676   END_TEST;
 677 }
 678
 679 int UtcDaliRenderTaskSetInputEnabled(void)
 680 {
 681   TestApplication application;
 682
 683   tet_infoline("Testing RenderTask::SetInputEnabled()");
 684
 685   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 686
 687   // Input is enabled by default
 688   RenderTask task = taskList.GetTask( 0u );
 689   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 690
 691   task.SetInputEnabled( false );
 692   DALI_TEST_CHECK( false == task.GetInputEnabled() );
 693
 694   task.SetInputEnabled( true );
 695   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 696   END_TEST;
 697 }
 698
 699 int UtcDaliRenderTaskGetInputEnabled(void)
 700 {
 701   TestApplication application;
 702
 703   tet_infoline("Testing RenderTask::GetInputEnabled()");
 704
 705   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 706
 707   // Input is enabled by default
 708   RenderTask task = taskList.GetTask( 0u );
 709   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 710
 711   RenderTask newTask = taskList.CreateTask();
 712   DALI_TEST_CHECK( true == newTask.GetInputEnabled() );
 713   END_TEST;
 714 }
 715
 716 int UtcDaliRenderTaskSetCameraActor(void)
 717 {
 718   TestApplication application;
 719
 720   tet_infoline("Testing RenderTask::SetCameraActor()");
 721
 722   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 723
 724   RenderTask task = taskList.GetTask( 0u );
 725
 726   Actor actor = task.GetCameraActor();
 727   DALI_TEST_CHECK( actor );
 728
 729   CameraActor newActor = CameraActor::New();
 730   DALI_TEST_CHECK( newActor );
 731
 732   task.SetCameraActor( newActor );
 733   DALI_TEST_CHECK( task.GetCameraActor() != actor );
 734   DALI_TEST_CHECK( task.GetCameraActor() == newActor );
 735   END_TEST;
 736 }
 737
 738 int UtcDaliRenderTaskGetCameraActor(void)
 739 {
 740   TestApplication application;
 741
 742   tet_infoline("Testing RenderTask::GetCameraActor()");
 743
 744   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 745
 746   RenderTask task = taskList.GetTask( 0u );
 747
 748   Actor actor = task.GetCameraActor();
 749   DALI_TEST_CHECK( actor );
 750
 751   RenderTask newTask = taskList.CreateTask();
 752   DALI_TEST_CHECK( actor == newTask.GetCameraActor() );
 753   END_TEST;
 754 }
 755
 756 int UtcDaliRenderTaskSetTargetFrameBuffer(void)
 757 {
 758   TestApplication application;
 759
 760   tet_infoline("Testing RenderTask::SetTargetFrameBuffer()");
 761
 762   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 763
 764   RenderTask task = taskList.GetTask( 0u );
 765
 766   // By default render-tasks do not render off-screen
 767   FrameBufferImage image = task.GetTargetFrameBuffer();
 768   DALI_TEST_CHECK( !image );
 769
 770   FrameBufferImage newImage = FrameBufferImage::New();
 771
 772   task.SetTargetFrameBuffer( newImage );
 773   DALI_TEST_CHECK( task.GetTargetFrameBuffer() == newImage );
 774   END_TEST;
 775 }
 776
 777 int UtcDaliRenderTaskGetTargetFrameBuffer(void)
 778 {
 779   TestApplication application;
 780
 781   tet_infoline("Testing RenderTask::GetTargetFrameBuffer()");
 782
 783   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 784
 785   RenderTask task = taskList.GetTask( 0u );
 786
 787   // By default render-tasks do not render off-screen
 788   FrameBufferImage image = task.GetTargetFrameBuffer();
 789   DALI_TEST_CHECK( !image );
 790
 791   RenderTask newTask = taskList.CreateTask();
 792   DALI_TEST_CHECK( !newTask.GetTargetFrameBuffer() );
 793   END_TEST;
 794 }
 795
 796 int UtcDaliRenderTaskSetScreenToFrameBufferFunction(void)
 797 {
 798   TestApplication application;
 799
 800   tet_infoline("Testing RenderTask::SetScreenToFrameBufferFunction()");
 801
 802   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 803
 804   RenderTask task = taskList.GetTask( 0u );
 805
 806   task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
 807
 808   Vector2 coordinates( 5, 10 );
 809   Vector2 convertedCoordinates( 6, 12 ); // + Vector(1, 2)
 810
 811   RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
 812   DALI_TEST_CHECK( func( coordinates ) );
 813   DALI_TEST_CHECK( coordinates == convertedCoordinates );
 814
 815   task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
 816   func = task.GetScreenToFrameBufferFunction();
 817   DALI_TEST_CHECK( func( coordinates ) );
 818
 819   task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
 820   func = task.GetScreenToFrameBufferFunction();
 821   DALI_TEST_CHECK( ! func( coordinates ) );
 822   END_TEST;
 823 }
 824
 825 int UtcDaliRenderTaskGetScreenToFrameBufferFunction(void)
 826 {
 827   TestApplication application;
 828
 829   tet_infoline("Testing RenderTask::GetScreenToFrameBufferFunction()");
 830
 831   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 832
 833   RenderTask task = taskList.GetTask( 0u );
 834
 835   Vector2 originalCoordinates( 5, 10 );
 836   Vector2 coordinates( 5, 10 );
 837
 838   RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
 839   DALI_TEST_CHECK( !func( coordinates ) ); // conversion should fail by default
 840   DALI_TEST_CHECK( coordinates == originalCoordinates ); // coordinates should not be modified
 841   END_TEST;
 842 }
 843
 844
 845 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActor(void)
 846 {
 847   TestApplication application;
 848   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor ");
 849
 850   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 851   RenderTask renderTask = taskList.CreateTask();
 852   Actor mappingActor = Actor::New();
 853   renderTask.SetScreenToFrameBufferMappingActor(mappingActor);
 854
 855   DALI_TEST_CHECK( mappingActor == renderTask.GetScreenToFrameBufferMappingActor() );
 856   END_TEST;
 857 }
 858
 859 int UtcDaliRenderTaskSetViewport(void)
 860 {
 861   TestApplication application;
 862
 863   tet_infoline("Testing RenderTask::SetViewport()");
 864
 865   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 866
 867   RenderTask task = taskList.GetTask( 0u );
 868
 869   Viewport viewport = task.GetViewport();
 870
 871   // By default the viewport should match the stage width/height
 872
 873   Vector2 stageSize = Stage::GetCurrent().GetSize();
 874   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
 875   DALI_TEST_CHECK( viewport == expectedViewport );
 876
 877   Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
 878   task.SetViewport( newViewport );
 879
 880   // Update (viewport is a property)
 881   application.SendNotification();
 882   application.Render();
 883
 884   DALI_TEST_CHECK( task.GetViewport() == newViewport );
 885   END_TEST;
 886 }
 887
 888 int UtcDaliRenderTaskGetViewport(void)
 889 {
 890   TestApplication application;
 891
 892   tet_infoline("Testing RenderTask::GetViewport()");
 893
 894   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 895
 896   RenderTask task = taskList.GetTask( 0u );
 897
 898   Viewport viewport = task.GetViewport();
 899
 900   // By default the viewport should match the stage width/height
 901
 902   Vector2 stageSize = Stage::GetCurrent().GetSize();
 903   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
 904   DALI_TEST_CHECK( viewport == expectedViewport );
 905
 906   RenderTask newTask = taskList.CreateTask();
 907   DALI_TEST_CHECK( newTask.GetViewport() == expectedViewport );
 908   END_TEST;
 909 }
 910
 911 int UtcDaliRenderTaskSetViewportPosition(void)
 912 {
 913   TestApplication application;
 914
 915   tet_infoline("Testing RenderTask::SetViewportPosition()");
 916
 917   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 918
 919   RenderTask task = taskList.GetTask( 0u );
 920
 921   Viewport viewport = task.GetViewport();
 922
 923   // By default the viewport should match the stage width/height
 924
 925   Vector2 stageSize = Stage::GetCurrent().GetSize();
 926   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
 927   DALI_TEST_CHECK( viewport == expectedViewport );
 928
 929   // 'Setter' test
 930   Vector2 newPosition(25.0f, 50.0f);
 931   task.SetViewportPosition( newPosition );
 932
 933   // Update (viewport is a property)
 934   application.SendNotification();
 935   application.Render();
 936
 937   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition, Math::MACHINE_EPSILON_1, TEST_LOCATION );
 938
 939   // Set by Property test
 940   Vector2 newPosition2(32.0f, 32.0f);
 941   task.SetProperty( RenderTask::Property::VIEWPORT_POSITION, newPosition2 );
 942
 943   // Update
 944   application.SendNotification();
 945   application.Render();
 946
 947   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
 948
 949   Vector2 newPosition3(64.0f, 0.0f);
 950   Animation animation = Animation::New(1.0f);
 951   animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_POSITION ), newPosition3, AlphaFunctions::Linear );
 952   animation.Play();
 953
 954   // Perform 1000ms worth of updates at which point animation should have completed.
 955   Wait(application, 1000);
 956   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
 957   END_TEST;
 958 }
 959
 960 int UtcDaliRenderTaskSetViewportSize(void)
 961 {
 962   TestApplication application;
 963
 964   tet_infoline("Testing RenderTask::SetViewportSize()");
 965
 966   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 967
 968   RenderTask task = taskList.GetTask( 0u );
 969
 970   Viewport viewport = task.GetViewport();
 971
 972   // By default the viewport should match the stage width/height
 973
 974   Vector2 stageSize = Stage::GetCurrent().GetSize();
 975   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
 976   DALI_TEST_CHECK( viewport == expectedViewport );
 977
 978   Vector2 newSize(128.0f, 64.0f);
 979   task.SetViewportSize( newSize );
 980
 981   // Update (viewport is a property)
 982   application.SendNotification();
 983   application.Render();
 984
 985   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize, Math::MACHINE_EPSILON_1, TEST_LOCATION );
 986
 987   // Set by Property test
 988   Vector2 newSize2(50.0f, 50.0f);
 989   task.SetProperty( RenderTask::Property::VIEWPORT_SIZE, newSize2 );
 990
 991   // Update
 992   application.SendNotification();
 993   application.Render();
 994
 995   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
 996
 997   Vector2 newSize3(10.0f, 10.0f);
 998   Animation animation = Animation::New(1.0f);
 999   animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_SIZE ), newSize3, AlphaFunctions::Linear );
1000   animation.Play();
1001
1002   // Perform 1000ms worth of updates at which point animation should have completed.
1003   Wait(application, 1000);
1004   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1005
1006   END_TEST;
1007 }
1008
1009 int UtcDaliRenderTaskSetClearColor(void)
1010 {
1011   TestApplication application;
1012
1013   tet_infoline("Testing RenderTask::SetClearColor()");
1014
1015   Vector4 testColor( 1.0f, 2.0f, 3.0f, 4.0f );
1016   Vector4 testColor2( 5.0f, 6.0f, 7.0f, 8.0f );
1017
1018   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1019
1020   RenderTask task = taskList.GetTask( 0u );
1021   DALI_TEST_CHECK( task.GetClearColor() != testColor );
1022
1023   task.SetClearColor( testColor );
1024
1025   // Wait a frame.
1026   Wait(application);
1027
1028   DALI_TEST_EQUALS( task.GetClearColor(), testColor, TEST_LOCATION );
1029
1030   task.SetProperty( RenderTask::Property::CLEAR_COLOR, testColor2 );
1031
1032   // Wait a frame.
1033   Wait(application);
1034
1035   DALI_TEST_EQUALS( task.GetClearColor(), testColor2, TEST_LOCATION );
1036   END_TEST;
1037 }
1038
1039 int UtcDaliRenderTaskGetClearColor(void)
1040 {
1041   TestApplication application;
1042
1043   tet_infoline("Testing RenderTask::GetClearColor()");
1044
1045   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1046   RenderTask task = taskList.GetTask( 0u );
1047   DALI_TEST_EQUALS( task.GetClearColor(), RenderTask::DEFAULT_CLEAR_COLOR, TEST_LOCATION );
1048   END_TEST;
1049 }
1050
1051 int UtcDaliRenderTaskSetClearEnabled(void)
1052 {
1053   TestApplication application;
1054
1055   tet_infoline("Testing RenderTask::SetClearEnabled()");
1056
1057   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1058
1059   RenderTask task = taskList.GetTask( 0u );
1060   DALI_TEST_CHECK( !task.GetClearEnabled() ); // defaults to false
1061
1062   task.SetClearEnabled( true );
1063   DALI_TEST_EQUALS( task.GetClearEnabled(), true, TEST_LOCATION );
1064
1065   task.SetClearEnabled( false );
1066   DALI_TEST_EQUALS( task.GetClearEnabled(), false, TEST_LOCATION );
1067   END_TEST;
1068 }
1069
1070 int UtcDaliRenderTaskGetClearEnabled(void)
1071 {
1072   TestApplication application;
1073
1074   tet_infoline("Testing RenderTask::GetClearEnabled()");
1075
1076   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1077
1078   RenderTask task = taskList.GetTask( 0u );
1079   DALI_TEST_CHECK( !task.GetClearEnabled() ); // defaults to false
1080   END_TEST;
1081 }
1082
1083 int UtcDaliRenderTaskSetRefreshRate(void)
1084 {
1085   TestApplication application;
1086
1087   tet_infoline("Testing RenderTask::SetRefreshRate()");
1088
1089   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1090
1091   // By default tasks will be processed every frame
1092   RenderTask task = taskList.GetTask( 0u );
1093   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1094
1095   task.SetRefreshRate( 2u ); // every-other frame
1096   DALI_TEST_CHECK( 2u == task.GetRefreshRate() );
1097
1098   task.SetRefreshRate( RenderTask::REFRESH_ALWAYS );
1099   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1100   END_TEST;
1101 }
1102
1103 int UtcDaliRenderTaskGetRefreshRate(void)
1104 {
1105   TestApplication application;
1106
1107   tet_infoline("Testing RenderTask::GetRefreshRate()");
1108
1109   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1110
1111   // By default tasks will be processed every frame
1112   RenderTask task = taskList.GetTask( 0u );
1113   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1114
1115   RenderTask newTask = taskList.CreateTask();
1116   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == newTask.GetRefreshRate() );
1117   END_TEST;
1118 }
1119
1120 int UtcDaliRenderTaskSignalFinished(void)
1121 {
1122   TestApplication application;
1123
1124   tet_infoline("Testing RenderTask::SignalFinished()");
1125
1126   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1127   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1128
1129   CameraActor offscreenCameraActor = CameraActor::New();
1130
1131   Stage::GetCurrent().Add( offscreenCameraActor );
1132
1133   BufferImage image = BufferImage::New( 10, 10 );
1134   ImageActor rootActor = ImageActor::New( image );
1135   rootActor.SetSize( 10, 10 );
1136   Stage::GetCurrent().Add( rootActor );
1137
1138   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1139   NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
1140   FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
1141
1142   // Flush all outstanding messages
1143   application.SendNotification();
1144   application.Render();
1145
1146   RenderTask newTask = taskList.CreateTask();
1147   newTask.SetCameraActor( offscreenCameraActor );
1148   newTask.SetSourceActor( rootActor );
1149   newTask.SetInputEnabled( false );
1150   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
1151   newTask.SetClearEnabled( true );
1152   newTask.SetExclusive( true );
1153   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
1154   newTask.SetTargetFrameBuffer( frameBufferImage );
1155
1156   // Framebuffer doesn't actually get created until Connected, i.e. by previous line
1157
1158   bool finished = false;
1159   RenderTaskFinished renderTaskFinished( finished );
1160   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1161
1162   // Flush the queue and render.
1163   application.SendNotification();
1164
1165   // 1 render to process render task, then wait for sync before finished msg is sent
1166   // from update to the event thread.
1167
1168   application.Render();
1169   application.SendNotification();
1170   DALI_TEST_CHECK( !finished );
1171
1172   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1173   DALI_TEST_CHECK( lastSyncObj != NULL );
1174
1175   application.Render();
1176   DALI_TEST_EQUALS( (application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
1177   application.SendNotification();
1178   DALI_TEST_CHECK( !finished );
1179
1180   application.Render();
1181   DALI_TEST_EQUALS( (application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
1182   application.SendNotification();
1183   DALI_TEST_CHECK( ! finished );
1184
1185   sync.SetObjectSynced( lastSyncObj, true );
1186
1187   application.Render();
1188   application.SendNotification();
1189   DALI_TEST_CHECK( !finished );
1190
1191   application.Render();
1192   application.SendNotification();
1193   DALI_TEST_CHECK( finished );
1194   finished = false;
1195
1196   application.Render(); // Double check no more finished signal
1197   application.SendNotification();
1198   DALI_TEST_CHECK( ! finished );
1199   END_TEST;
1200 }
1201
1202
1203 int UtcDaliRenderTaskContinuous01(void)
1204 {
1205   TestApplication application;
1206
1207   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not staged)\nPOST:continuous renders, no Finished signal");
1208
1209   // SETUP AN OFFSCREEN RENDER TASK
1210   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1211   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1212   drawTrace.Enable(true);
1213
1214   Actor rootActor = Actor::New();
1215   Stage::GetCurrent().Add( rootActor );
1216
1217   CameraActor offscreenCameraActor = CameraActor::New();
1218   Stage::GetCurrent().Add( offscreenCameraActor );
1219
1220   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1221   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1222   Integration::ResourceId imageRequestId = imageRequest->GetId();
1223   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1224
1225   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1226   bool finished = false;
1227   RenderTaskFinished renderTaskFinished( finished );
1228   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1229   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1230   application.SendNotification();
1231
1232   // START PROCESS/RENDER                     Input,    Expected  Input, Expected, KeepUpdating
1233   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, false,   finished, false, true ) );
1234   application.GetPlatform().ClearReadyResources();
1235
1236   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, false,   finished, false, false ) );
1237
1238   // ADD SOURCE ACTOR TO STAGE - expect continuous renders to start, no finished signal
1239   Stage::GetCurrent().Add(secondRootActor);
1240   application.SendNotification();
1241
1242   // CONTINUE PROCESS/RENDER                  Input,    Expected  Input,    Expected
1243   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, true,    finished, false, true ) );
1244   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, true,    finished, false, false ) );
1245   END_TEST;
1246 }
1247
1248
1249 int UtcDaliRenderTaskContinuous02(void)
1250 {
1251   TestApplication application;
1252
1253   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not visible)\nPOST:continuous renders, no Finished signal");
1254
1255   // SETUP AN OFFSCREEN RENDER TASK
1256   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1257   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1258   drawTrace.Enable(true);
1259
1260   Actor rootActor = Actor::New();
1261   Stage::GetCurrent().Add( rootActor );
1262
1263   CameraActor offscreenCameraActor = CameraActor::New();
1264   Stage::GetCurrent().Add( offscreenCameraActor );
1265
1266   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1267   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1268   Integration::ResourceId imageRequestId = imageRequest->GetId();
1269   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1270   Stage::GetCurrent().Add(secondRootActor);
1271   secondRootActor.SetVisible(false);
1272
1273   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1274   bool finished = false;
1275   RenderTaskFinished renderTaskFinished( finished );
1276   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1277   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1278   application.SendNotification();
1279
1280   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1281   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1282   application.GetPlatform().ClearReadyResources();
1283   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false ) );
1284
1285   // MAKE SOURCE ACTOR VISIBLE - expect continuous renders to start, no finished signal
1286   secondRootActor.SetVisible(true);
1287   application.SendNotification();
1288
1289   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
1290   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1291   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1292   END_TEST;
1293 }
1294
1295 int UtcDaliRenderTaskContinuous03(void)
1296 {
1297   TestApplication application;
1298
1299   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (camera actor not staged)\nPOST:continuous renders, no Finished signal");
1300
1301   // SETUP AN OFFSCREEN RENDER TASK
1302   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1303   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1304   drawTrace.Enable(true);
1305
1306   Actor rootActor = Actor::New();
1307   Stage::GetCurrent().Add( rootActor );
1308
1309   CameraActor offscreenCameraActor = CameraActor::New();
1310   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1311   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1312   Integration::ResourceId imageRequestId = imageRequest->GetId();
1313   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1314   Stage::GetCurrent().Add(secondRootActor);
1315
1316   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1317   bool finished = false;
1318   RenderTaskFinished renderTaskFinished( finished );
1319   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1320   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1321   application.SendNotification();
1322
1323   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1324   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1325   application.GetPlatform().ClearReadyResources();
1326   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false ) );
1327
1328   // ADD CAMERA ACTOR TO STAGE - expect continuous renders to start, no finished signal
1329   Stage::GetCurrent().Add( offscreenCameraActor );
1330   application.SendNotification();
1331
1332   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
1333   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1334   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1335   END_TEST;
1336 }
1337
1338
1339 int UtcDaliRenderTaskContinuous04(void)
1340 {
1341   TestApplication application;
1342
1343   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: Resource not ready\nPOST:continuous renders, no Finished signal");
1344
1345   // SETUP AN OFFSCREEN RENDER TASK
1346   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1347   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1348   drawTrace.Enable(true);
1349
1350   Actor rootActor = Actor::New();
1351   Stage::GetCurrent().Add( rootActor );
1352
1353   CameraActor offscreenCameraActor = CameraActor::New();
1354   Stage::GetCurrent().Add( offscreenCameraActor );
1355   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1356   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1357   Integration::ResourceId imageRequestId = imageRequest->GetId();
1358   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1359   Stage::GetCurrent().Add(secondRootActor);
1360
1361   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1362   bool finished = false;
1363   RenderTaskFinished renderTaskFinished( finished );
1364   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1365   application.SendNotification();
1366
1367   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1368   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1369   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1370
1371   // FINISH RESOURCE LOADING - expect 'continuous' renders to start, no finished signal
1372   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1373   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1374   END_TEST;
1375 }
1376
1377
1378 int UtcDaliRenderTaskOnce01(void)
1379 {
1380   TestApplication application;
1381
1382   tet_infoline("Testing RenderTask Render Once GlSync, using loading image\nPRE: Resources not ready, Source not visible\nPOST: Finished signal sent once only");
1383
1384   // SETUP AN OFFSCREEN RENDER TASK
1385   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1386   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1387   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1388   drawTrace.Enable(true);
1389
1390   Actor rootActor = Actor::New();
1391   Stage::GetCurrent().Add( rootActor );
1392
1393   CameraActor offscreenCameraActor = CameraActor::New();
1394   Stage::GetCurrent().Add( offscreenCameraActor );
1395   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1396   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1397   Integration::ResourceId imageRequestId = imageRequest->GetId();
1398   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1399
1400   Stage::GetCurrent().Add(secondRootActor);
1401
1402   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
1403   bool finished = false;
1404   RenderTaskFinished renderTaskFinished( finished );
1405   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1406   application.SendNotification();
1407
1408   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1409   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1410   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1411
1412   // MAKE SOURCE VISIBLE
1413   secondRootActor.SetVisible(true);
1414   application.SendNotification();
1415   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1416   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1417
1418   // FINISH RESOURCE LOADING - expect no rendering yet
1419   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1420   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1421   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1422   DALI_TEST_CHECK( lastSyncObj != NULL );
1423
1424   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1425   application.GetPlatform().ClearReadyResources();
1426   sync.SetObjectSynced( lastSyncObj, true );
1427   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true  ) );
1428   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1429   END_TEST;
1430 }
1431
1432 int UtcDaliRenderTaskOnce02(void)
1433 {
1434   TestApplication application;
1435
1436   tet_infoline("Testing RenderTask Render Once GlSync, using loading image. Switch from render always after ready to render once\n"
1437                "PRE: Render task ready, Image not loaded\n"
1438                "POST: Finished signal sent only once");
1439
1440   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1441   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1442   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1443   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1444   drawTrace.Enable(true);
1445
1446   Actor rootActor = Actor::New();
1447   Stage::GetCurrent().Add( rootActor );
1448
1449   CameraActor offscreenCameraActor = CameraActor::New();
1450   Stage::GetCurrent().Add( offscreenCameraActor );
1451   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1452   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1453   Integration::ResourceId imageRequestId = imageRequest->GetId();
1454   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1455   Stage::GetCurrent().Add(secondRootActor);
1456
1457   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1458   bool finished = false;
1459   RenderTaskFinished renderTaskFinished( finished );
1460   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1461   application.SendNotification();
1462
1463   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1464   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1465   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1466
1467   // FINISH RESOURCE LOADING
1468   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1469   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1470   application.GetPlatform().ClearReadyResources();
1471   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1472
1473   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1474   application.SendNotification(); //         Input,    Expected  Input,    Expected
1475   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1476   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1477   DALI_TEST_CHECK( lastSyncObj != NULL );
1478
1479   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1480   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1481   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1482   sync.SetObjectSynced( lastSyncObj, true );
1483   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
1484   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1485
1486   END_TEST;
1487 }
1488
1489
1490 int UtcDaliRenderTaskOnce03(void)
1491 {
1492   TestApplication application;
1493
1494   tet_infoline("Testing RenderTask Render Once GlSync\n"
1495                "Switch from Render always after ready to render once with resources unready\n"
1496                "PRE: Everything ready to render\n"
1497                "POST: Finished signal sent once");
1498
1499   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1500   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1501   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1502   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1503   drawTrace.Enable(true);
1504
1505   Actor rootActor = Actor::New();
1506   Stage::GetCurrent().Add( rootActor );
1507
1508   CameraActor offscreenCameraActor = CameraActor::New();
1509   Stage::GetCurrent().Add( offscreenCameraActor );
1510   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1511   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1512   Integration::ResourceId imageRequestId = imageRequest->GetId();
1513   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1514   Stage::GetCurrent().Add(secondRootActor);
1515
1516   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1517   bool finished = false;
1518   RenderTaskFinished renderTaskFinished( finished );
1519   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1520   application.SendNotification();
1521
1522   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1523   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1524   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1525
1526   // CHANGE TO RENDER ONCE
1527   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1528   application.SendNotification(); //         Input,    Expected  Input,    Expected
1529   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1530   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1531
1532   // FINISH RESOURCE LOADING
1533   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1534   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1535   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1536   DALI_TEST_CHECK( lastSyncObj != NULL );
1537   application.GetPlatform().ClearReadyResources();
1538
1539   sync.SetObjectSynced( lastSyncObj, true );
1540   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
1541   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1542
1543   END_TEST;
1544 }
1545
1546 #if 0
1547 //int UtcDaliRenderTaskOnce04(void)
1548 {
1549   TestApplication application;
1550
1551   tet_infoline("Testing RenderTask Render Once GlSync\n"
1552                "During RenderOnce, make ready resources unready before sending first finished signal\n"
1553                "PRE: Everything ready.\n"
1554                "POST: Finished signal sent only once");
1555
1556   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1557   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1558   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1559   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1560   drawTrace.Enable(true);
1561
1562   Actor rootActor = Actor::New();
1563   Stage::GetCurrent().Add( rootActor );
1564
1565   CameraActor offscreenCameraActor = CameraActor::New();
1566   Stage::GetCurrent().Add( offscreenCameraActor );
1567   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1568   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1569   Integration::ResourceId imageRequestId = imageRequest->GetId();
1570   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1571   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1572   application.Render();
1573
1574   Stage::GetCurrent().Add(secondRootActor);
1575   application.GetPlatform().ClearReadyResources();
1576
1577   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1578   bool finished = false;
1579   RenderTaskFinished renderTaskFinished( finished );
1580   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1581   application.SendNotification();
1582
1583   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1584   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1585   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1586
1587   // CHANGE TO RENDER ONCE, RESOURCES BECOME NOT READY
1588   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1589
1590   // Doesn't work...
1591   ReloadImage(application, secondRootActor.GetImage());
1592   application.SendNotification(); //         Input,    Expected  Input,    Expected
1593
1594   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1595   DALI_TEST_EQUALS( secondRootActor.GetImage().GetLoadingState(), Dali::ResourceLoading, TEST_LOCATION);
1596   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1597
1598   // FINISH RESOURCE LOADING
1599   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1600   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1601   application.GetPlatform().ClearReadyResources();
1602   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1603   DALI_TEST_CHECK( lastSyncObj != NULL );
1604
1605   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1606   sync.SetObjectSynced( lastSyncObj, true );
1607   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
1608   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, true  ) );
1609
1610   // Finished rendering - expect no more renders, no more signals:
1611   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1612   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1613   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1614   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1615   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1616   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1617   END_TEST;
1618 }
1619 #endif
1620
1621 int UtcDaliRenderTaskOnce05(void)
1622 {
1623   TestApplication application;
1624
1625   tet_infoline("Testing RenderTask Render Once GLSync\n"
1626                "Render once, Second call to SetRefreshRate(ONCE) triggers only one more finished signal\n"
1627                "PRE: Everything ready\n"
1628                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
1629
1630   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1631   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1632   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1633   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1634   drawTrace.Enable(true);
1635
1636   Actor rootActor = Actor::New();
1637   Stage::GetCurrent().Add( rootActor );
1638
1639   CameraActor offscreenCameraActor = CameraActor::New();
1640   Stage::GetCurrent().Add( offscreenCameraActor );
1641   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1642   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1643   Integration::ResourceId imageRequestId = imageRequest->GetId();
1644   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1645   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1646   application.Render();
1647   application.GetPlatform().ClearReadyResources();
1648
1649   Stage::GetCurrent().Add(secondRootActor);
1650
1651   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1652   bool finished = false;
1653   RenderTaskFinished renderTaskFinished( finished );
1654   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1655   application.SendNotification();
1656
1657   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1658   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1659   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1660
1661   // CHANGE TO RENDER ONCE,
1662   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1663   application.SendNotification();
1664   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1665   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1666   DALI_TEST_CHECK( lastSyncObj != NULL );
1667
1668   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1669   sync.SetObjectSynced( lastSyncObj, true );
1670   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1671   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false  ) );
1672
1673   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1674   application.SendNotification();
1675   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1676   lastSyncObj = sync.GetLastSyncObject();
1677   DALI_TEST_CHECK( lastSyncObj != NULL );
1678
1679   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1680   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1681   sync.SetObjectSynced( lastSyncObj, true );
1682   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1683   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1684   END_TEST;
1685 }
1686
1687 int UtcDaliRenderTaskOnce06(void)
1688 {
1689   TestApplication application;
1690
1691   tet_infoline("Testing RenderTask Render Once GLSync\n"
1692                "Render once, Call to SetRefreshRate(ONCE) in Finished signal callback triggers "
1693                "another render & another finished signal\n"
1694                "PRE: Everything ready\n"
1695                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
1696
1697
1698   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1699   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1700   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1701   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1702   drawTrace.Enable(true);
1703
1704   Actor rootActor = Actor::New();
1705   Stage::GetCurrent().Add( rootActor );
1706
1707   CameraActor offscreenCameraActor = CameraActor::New();
1708   Stage::GetCurrent().Add( offscreenCameraActor );
1709   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1710   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1711   Integration::ResourceId imageRequestId = imageRequest->GetId();
1712   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1713   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1714   application.Render();
1715   application.GetPlatform().ClearReadyResources();
1716
1717   Stage::GetCurrent().Add(secondRootActor);
1718
1719   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1720   bool finished = false;
1721
1722   ConnectionTracker connectionTracker;
1723   RenderTaskFinishedRenderAgain renderTaskFinishedRenderAgain( finished );
1724   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinishedRenderAgain );
1725
1726   application.SendNotification();
1727
1728   // Expect 2 frames to be drawn.
1729   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1730   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1731   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1732   DALI_TEST_CHECK( lastSyncObj == NULL );
1733   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1734
1735   // CHANGE TO RENDER ONCE,
1736   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1737   application.SendNotification();
1738   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1739   lastSyncObj = sync.GetLastSyncObject();
1740   DALI_TEST_CHECK( lastSyncObj != NULL );
1741
1742   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1743   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1744
1745   sync.SetObjectSynced( lastSyncObj, true );
1746   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1747   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1748   application.SendNotification();
1749
1750   // Expect SetRefreshRate to have been called again
1751   // Prevent next finished signal calling refresh once again
1752   RenderTaskFinished renderTaskFinished( finished );
1753   connectionTracker.DisconnectAll();
1754   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinished );
1755   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1756   lastSyncObj = sync.GetLastSyncObject();
1757   DALI_TEST_CHECK( lastSyncObj != NULL );
1758
1759   sync.SetObjectSynced( lastSyncObj, true );
1760   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1761   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1762   END_TEST;
1763 }
1764
1765
1766 int UtcDaliRenderTaskOnce07(void)
1767 {
1768   TestApplication application;
1769
1770   tet_infoline("Testing RenderTask Render Once GlSync\n"
1771                "SetRefreshRate(ONCE) again before first finished signal has been sent.\n"
1772                "PRE: resources ready\n"
1773                "POST: Only 1 finished signal sent.");
1774
1775   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1776   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1777   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1778   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1779   drawTrace.Enable(true);
1780
1781   Actor rootActor = Actor::New();
1782   Stage::GetCurrent().Add( rootActor );
1783
1784   CameraActor offscreenCameraActor = CameraActor::New();
1785   Stage::GetCurrent().Add( offscreenCameraActor );
1786   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1787   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1788   Integration::ResourceId imageRequestId = imageRequest->GetId();
1789   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1790   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1791   application.Render();
1792   application.GetPlatform().ClearReadyResources();
1793
1794   Stage::GetCurrent().Add(secondRootActor);
1795
1796   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1797   bool finished = false;
1798   RenderTaskFinished renderTaskFinished( finished );
1799   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1800   application.SendNotification();
1801
1802   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1803   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1804   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1805
1806   // CHANGE TO RENDER ONCE,
1807   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1808   application.SendNotification();
1809   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1810   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1811   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1812
1813   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1814   application.SendNotification();
1815   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1816   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1817   DALI_TEST_CHECK( lastSyncObj != NULL );
1818
1819   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1820   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1821   sync.SetObjectSynced( lastSyncObj, true );
1822   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1823   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1824
1825   END_TEST;
1826 }
1827
1828
1829
1830 int UtcDaliRenderTaskOnce08(void)
1831 {
1832   TestApplication application;
1833
1834   tet_infoline("Testing RenderTask Render Once GlSync\n"
1835                "SetRefreshRate(ONCE), resource load failed completes render task.\n"
1836                "PRE: resources not ready\n"
1837                "POST: Only 1 finished signal sent.");
1838
1839   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1840   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1841   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1842   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1843   drawTrace.Enable(true);
1844
1845   Actor rootActor = Actor::New();
1846   Stage::GetCurrent().Add( rootActor );
1847
1848   CameraActor offscreenCameraActor = CameraActor::New();
1849   Stage::GetCurrent().Add( offscreenCameraActor );
1850   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1851   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1852   Integration::ResourceId imageRequestId = imageRequest->GetId();
1853   Stage::GetCurrent().Add(secondRootActor);
1854
1855   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1856   bool finished = false;
1857   RenderTaskFinished renderTaskFinished( finished );
1858   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1859   application.SendNotification();
1860
1861   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1862   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1863   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1864
1865   // CHANGE TO RENDER ONCE,
1866   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1867   application.SendNotification();
1868   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1869   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1870   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1871
1872   tet_printf("  FailImageLoad\n");
1873
1874   FailImageLoad(application, imageRequestId); // Need to run Update again for this to complete
1875   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) ); // nothing to draw
1876   application.SendNotification();
1877
1878   // Drawing empty framebuffer, so will still get a GL sync
1879   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1880   DALI_TEST_CHECK( lastSyncObj != NULL );
1881
1882   // Expect finished signal, as all resources are complete
1883   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, true, false ) );
1884
1885   END_TEST;
1886 }
1887
1888
1889
1890 int UtcDaliRenderTaskOnceNoSync01(void)
1891 {
1892   TestApplication application;
1893
1894   tet_infoline("Testing RenderTask Render Once, using loading image\nPRE: Resources not ready, Source not visible\nPOST: Finished signal sent once only");
1895
1896   // SETUP AN OFFSCREEN RENDER TASK
1897   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1898   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1899   drawTrace.Enable(true);
1900
1901   Actor rootActor = Actor::New();
1902   Stage::GetCurrent().Add( rootActor );
1903
1904   CameraActor offscreenCameraActor = CameraActor::New();
1905   Stage::GetCurrent().Add( offscreenCameraActor );
1906   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1907   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1908   Integration::ResourceId imageRequestId = imageRequest->GetId();
1909   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1910
1911   Stage::GetCurrent().Add(secondRootActor);
1912
1913   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
1914   bool finished = false;
1915   RenderTaskFinished renderTaskFinished( finished );
1916   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1917   application.SendNotification();
1918
1919   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1920   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1921   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1922
1923   // FINISH RESOURCE LOADING - expect immediate rendering yet
1924   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1925   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1926   application.GetPlatform().ClearReadyResources();
1927   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false ) );
1928   END_TEST;
1929 }
1930
1931 int UtcDaliRenderTaskOnceNoSync02(void)
1932 {
1933   TestApplication application;
1934
1935   tet_infoline("Testing RenderTask Render Once, using loading image. Switch from render always after ready to render once\n"
1936                "PRE: Render task ready, Image not loaded\n"
1937                "POST: Finished signal sent only once");
1938
1939   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1940   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1941   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1942   drawTrace.Enable(true);
1943
1944   Actor rootActor = Actor::New();
1945   Stage::GetCurrent().Add( rootActor );
1946
1947   CameraActor offscreenCameraActor = CameraActor::New();
1948   Stage::GetCurrent().Add( offscreenCameraActor );
1949   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1950   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1951   Integration::ResourceId imageRequestId = imageRequest->GetId();
1952   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1953   Stage::GetCurrent().Add(secondRootActor);
1954
1955   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
1956   bool finished = false;
1957   RenderTaskFinished renderTaskFinished( finished );
1958   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1959   application.SendNotification();
1960
1961   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1962   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1963   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1964
1965   // FINISH RESOURCE LOADING
1966   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1967   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1968   application.GetPlatform().ClearReadyResources();
1969
1970   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1971   application.SendNotification(); //         Input,    Expected  Input,    Expected
1972   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1973   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1974   END_TEST;
1975 }
1976
1977
1978 int UtcDaliRenderTaskOnceNoSync03(void)
1979 {
1980   TestApplication application;
1981
1982   tet_infoline("Testing RenderTask Render Once\n"
1983                "Switch from Render always after ready to render once with resources unready\n"
1984                "PRE: Everything ready to render\n"
1985                "POST: Finished signal sent once");
1986
1987   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1988   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1989   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1990   drawTrace.Enable(true);
1991
1992   Actor rootActor = Actor::New();
1993   Stage::GetCurrent().Add( rootActor );
1994
1995   CameraActor offscreenCameraActor = CameraActor::New();
1996   Stage::GetCurrent().Add( offscreenCameraActor );
1997   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1998   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1999   Integration::ResourceId imageRequestId = imageRequest->GetId();
2000   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2001   Stage::GetCurrent().Add(secondRootActor);
2002
2003   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2004   bool finished = false;
2005   RenderTaskFinished renderTaskFinished( finished );
2006   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2007   application.SendNotification();
2008
2009   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2010   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2011   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2012
2013   // CHANGE TO RENDER ONCE
2014   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2015   application.SendNotification(); //         Input,    Expected  Input,    Expected
2016   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2017   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2018
2019   // FINISH RESOURCE LOADING
2020   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2021   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2022   application.GetPlatform().ClearReadyResources();
2023   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2024   END_TEST;
2025 }
2026
2027 #if 0
2028 //int UtcDaliRenderTaskOnceNoSync04(void)
2029 {
2030   TestApplication application;
2031
2032   tet_infoline("Testing RenderTask Render Once\n"
2033                "During RenderOnce, make ready resources unready before sending first finished signal\n"
2034                "PRE: Everything ready.\n"
2035                "POST: Finished signal sent only once");
2036
2037   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2038   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2039   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2040   drawTrace.Enable(true);
2041
2042   Actor rootActor = Actor::New();
2043   Stage::GetCurrent().Add( rootActor );
2044
2045   CameraActor offscreenCameraActor = CameraActor::New();
2046   Stage::GetCurrent().Add( offscreenCameraActor );
2047   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2048   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2049   Integration::ResourceId imageRequestId = imageRequest->GetId();
2050   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2051   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2052   application.Render();
2053   application.GetPlatform().ClearReadyResources();
2054
2055   Stage::GetCurrent().Add(secondRootActor);
2056
2057   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2058   bool finished = false;
2059   RenderTaskFinished renderTaskFinished( finished );
2060   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2061   application.SendNotification();
2062
2063   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2064   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2065   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2066
2067   // CHANGE TO RENDER ONCE, RESOURCES BECOME NOT READY
2068   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2069
2070   // Doesn't work...
2071   ReloadImage(application, secondRootActor.GetImage());
2072   application.SendNotification(); //         Input,    Expected  Input,    Expected
2073
2074   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2075   DALI_TEST_EQUALS( secondRootActor.GetImage().GetLoadingState(), Dali::ResourceLoading, TEST_LOCATION);
2076   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2077
2078   // FINISH RESOURCE LOADING
2079   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2080   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, true, true ) );
2081   application.GetPlatform().ClearReadyResources();
2082   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2083   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
2084   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2085   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2086   END_TEST;
2087 }
2088 #endif
2089
2090 int UtcDaliRenderTaskOnceNoSync05(void)
2091 {
2092   TestApplication application;
2093
2094   tet_infoline("Testing RenderTask Render Once\n"
2095                "Render once, Second call to SetRefreshRate(ONCE) triggers only one more finished signal\n"
2096                "PRE: Everything ready\n"
2097                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
2098
2099   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2100   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2101   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2102   drawTrace.Enable(true);
2103
2104   Actor rootActor = Actor::New();
2105   Stage::GetCurrent().Add( rootActor );
2106
2107   CameraActor offscreenCameraActor = CameraActor::New();
2108   Stage::GetCurrent().Add( offscreenCameraActor );
2109   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2110   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2111   Integration::ResourceId imageRequestId = imageRequest->GetId();
2112   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2113   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2114   application.Render();
2115   application.GetPlatform().ClearReadyResources();
2116
2117   Stage::GetCurrent().Add(secondRootActor);
2118
2119   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2120   bool finished = false;
2121   RenderTaskFinished renderTaskFinished( finished );
2122   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2123   application.SendNotification();
2124
2125   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2126   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2127   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2128
2129   // CHANGE TO RENDER ONCE,
2130   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2131   application.SendNotification();
2132   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2133   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2134
2135   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2136   application.SendNotification();
2137   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2138   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2139   END_TEST;
2140 }
2141
2142 int UtcDaliRenderTaskOnceNoSync06(void)
2143 {
2144   TestApplication application;
2145
2146   tet_infoline("Testing RenderTask Render Once\n"
2147                "Render once, Call to SetRefreshRate(ONCE) in Finished signal callback triggers\n"
2148                "another render & another finished signal\n"
2149                "PRE: Everything ready\n"
2150                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
2151
2152
2153   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2154   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2155   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2156   drawTrace.Enable(true);
2157
2158   Actor rootActor = Actor::New();
2159   Stage::GetCurrent().Add( rootActor );
2160
2161   CameraActor offscreenCameraActor = CameraActor::New();
2162   Stage::GetCurrent().Add( offscreenCameraActor );
2163   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2164   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2165   Integration::ResourceId imageRequestId = imageRequest->GetId();
2166   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2167   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2168   application.Render();
2169   application.GetPlatform().ClearReadyResources();
2170
2171   Stage::GetCurrent().Add(secondRootActor);
2172
2173   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2174   bool finished = false;
2175
2176   ConnectionTracker connectionTracker;
2177   RenderTaskFinishedRenderAgain renderTaskFinishedRenderAgain( finished );
2178   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinishedRenderAgain );
2179
2180   application.SendNotification();
2181
2182   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2183   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2184   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2185
2186   // CHANGE TO RENDER ONCE,
2187   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2188   application.SendNotification();
2189   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2190   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2191
2192   // Expect SetRefreshRate to have been called again
2193   // Prevent next finished signal calling refresh once again
2194   RenderTaskFinished renderTaskFinished( finished );
2195   connectionTracker.DisconnectAll();
2196   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinished );
2197
2198   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2199   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2200   END_TEST;
2201 }
2202
2203
2204 int UtcDaliRenderTaskOnceNoSync07(void)
2205 {
2206   TestApplication application;
2207
2208   tet_infoline("Testing RenderTask Render Once\n"
2209                "SetRefreshRate(ONCE) again before first finished signal has been sent.\n"
2210                "PRE: resources ready\n"
2211                "POST: Only 1 finished signal sent.");
2212
2213   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2214   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2215   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2216   drawTrace.Enable(true);
2217
2218   Actor rootActor = Actor::New();
2219   Stage::GetCurrent().Add( rootActor );
2220
2221   CameraActor offscreenCameraActor = CameraActor::New();
2222   Stage::GetCurrent().Add( offscreenCameraActor );
2223   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2224   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2225   Integration::ResourceId imageRequestId = imageRequest->GetId();
2226   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2227   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2228   application.Render();
2229   application.GetPlatform().ClearReadyResources();
2230
2231   Stage::GetCurrent().Add(secondRootActor);
2232
2233   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2234   bool finished = false;
2235   RenderTaskFinished renderTaskFinished( finished );
2236   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2237   application.SendNotification();
2238
2239   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2240   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2241   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2242
2243   // CHANGE TO RENDER ONCE,
2244   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2245   application.SendNotification();
2246   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2247   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2248
2249   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2250   application.SendNotification();
2251   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2252   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2253   END_TEST;
2254 }
2255
2256 int UtcDaliRenderTaskOnceNoSync08(void)
2257 {
2258   TestApplication application;
2259
2260   tet_infoline("Testing RenderTask Render Once\n"
2261                "SetRefreshRate(ONCE), resource load failed, completes render task.\n"
2262                "PRE: resources not ready\n"
2263                "POST: Only 1 finished signal sent.");
2264
2265   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2266   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2267   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2268   drawTrace.Enable(true);
2269
2270   Actor rootActor = Actor::New();
2271   Stage::GetCurrent().Add( rootActor );
2272
2273   CameraActor offscreenCameraActor = CameraActor::New();
2274   Stage::GetCurrent().Add( offscreenCameraActor );
2275   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2276   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2277   Integration::ResourceId imageRequestId = imageRequest->GetId();
2278   Stage::GetCurrent().Add(secondRootActor);
2279
2280   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2281   bool finished = false;
2282   RenderTaskFinished renderTaskFinished( finished );
2283   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2284   application.SendNotification();
2285
2286   // START PROCESS/RENDER                    Input,     Expected  Input,    Expected
2287   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2288   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2289
2290   // CHANGE TO RENDER ONCE,
2291   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2292   application.SendNotification();
2293   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2294   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2295   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2296
2297   FailImageLoad(application, imageRequestId); // Need to run Update again for this to complete
2298   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) ); // nothing to draw
2299   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, true,  false  ) );
2300
2301   END_TEST;
2302 }
2303
2304
2305
2306 int UtcDaliRenderTaskOnceChain01(void)
2307 {
2308   TestApplication application;
2309
2310   tet_infoline("Testing RenderTask Render Once Chained render tasks\n"
2311                "SetRefreshRate(ONCE), resource load completes, both render tasks render.\n"
2312                "PRE: resources not ready\n"
2313                "POST: 2 finished signals sent.");
2314
2315   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2316   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2317   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2318   drawTrace.Enable(true);
2319
2320   Actor defaultRootActor = Actor::New(); // Root for default RT
2321   Stage::GetCurrent().Add( defaultRootActor );
2322
2323   CameraActor offscreenCameraActor = CameraActor::New();
2324   Stage::GetCurrent().Add( offscreenCameraActor );
2325   ImageActor firstRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2326   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2327   Integration::ResourceId imageRequestId = imageRequest->GetId();
2328   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2329   Stage::GetCurrent().Add(firstRootActor);
2330
2331   // first render task
2332   RenderTask firstTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, firstRootActor, RenderTask::REFRESH_ONCE, false);
2333   bool firstFinished = false;
2334   RenderTaskFinished renderTask1Finished( firstFinished );
2335   firstTask.FinishedSignal().Connect( &application, renderTask1Finished );
2336
2337   // Second render task
2338   FrameBufferImage fbo = firstTask.GetTargetFrameBuffer();
2339   ImageActor secondRootActor = ImageActor::New( fbo );
2340   Stage::GetCurrent().Add(secondRootActor);
2341   RenderTask secondTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2342   bool secondFinished = false;
2343   RenderTaskFinished renderTask2Finished( secondFinished );
2344   secondTask.FinishedSignal().Connect( &application, renderTask2Finished );
2345
2346   application.SendNotification();
2347
2348   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2349   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
2350   DALI_TEST_CHECK( secondFinished == false );
2351   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
2352   DALI_TEST_CHECK( secondFinished == false );
2353
2354   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2355   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
2356   DALI_TEST_CHECK( secondFinished == false );
2357   application.GetPlatform().ClearReadyResources();
2358
2359   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,  firstFinished, true,  false ) );
2360   DALI_TEST_CHECK( secondFinished == true );
2361
2362   END_TEST;
2363 }
2364
2365 int UtcDaliRenderTaskProperties(void)
2366 {
2367   TestApplication application;
2368
2369   RenderTask task = Stage::GetCurrent().GetRenderTaskList().CreateTask();
2370
2371   Property::IndexContainer indices;
2372   task.GetPropertyIndices( indices );
2373   DALI_TEST_CHECK( ! indices.empty() );
2374   DALI_TEST_EQUALS( indices.size(), task.GetPropertyCount(), TEST_LOCATION );
2375   END_TEST;
2376 }
2377
2378 int UtcDaliRenderTaskSetScreenToFrameBufferMappingActor(void)
2379 {
2380   TestApplication application;
2381   tet_infoline("Testing RenderTask::SetScreenToFrameBufferMappingActor ");
2382
2383   Stage stage = Stage::GetCurrent();
2384   Size stageSize = stage.GetSize();
2385   Actor mappingActor = Actor::New();
2386   Vector2 scale( 0.6f, 0.75f);
2387   Vector2 offset( stageSize.x*0.1f, stageSize.y*0.15f);
2388   mappingActor.SetSize( stageSize * scale );
2389   mappingActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
2390   mappingActor.SetPosition( offset.x, offset.y );
2391   stage.Add( mappingActor );
2392
2393   Actor offscreenActor = Actor::New();
2394   offscreenActor.SetSize( stageSize );
2395   offscreenActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
2396   stage.Add( offscreenActor );
2397
2398   RenderTaskList taskList = stage.GetRenderTaskList();
2399   RenderTask renderTask = taskList.CreateTask();
2400   FrameBufferImage frameBufferImage =  FrameBufferImage::New(stageSize.width*scale.x, stageSize.height*scale.y, Pixel::A8, Image::NEVER);
2401   renderTask.SetSourceActor( offscreenActor );
2402   renderTask.SetExclusive( true );
2403   renderTask.SetInputEnabled( true );
2404   renderTask.SetTargetFrameBuffer( frameBufferImage );
2405   renderTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
2406   renderTask.SetScreenToFrameBufferMappingActor( mappingActor );
2407   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2408
2409   // Render and notify
2410   application.SendNotification();
2411   application.Render();
2412   application.Render();
2413   application.SendNotification();
2414
2415   Vector2 screenCoordinates( stageSize.x * 0.05f, stageSize.y * 0.05f );
2416   Dali::HitTestAlgorithm::Results results;
2417   DALI_TEST_CHECK( !results.actor );
2418   DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
2419   // miss expected, results not changed
2420   DALI_TEST_CHECK( false == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2421   DALI_TEST_CHECK( !results.actor );
2422   DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
2423
2424   screenCoordinates.x = stageSize.x * 0.265f;
2425   screenCoordinates.y = stageSize.y * 0.33f;
2426   results.actor = Actor();
2427   results.actorCoordinates = Vector2::ZERO;
2428   // hit expected, results changed
2429   DALI_TEST_CHECK( true == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2430   DALI_TEST_CHECK( results.actor  == offscreenActor );
2431   DALI_TEST_EQUALS( (screenCoordinates-offset)/scale , results.actorCoordinates, 0.1f, TEST_LOCATION );
2432
2433   screenCoordinates.x = stageSize.x * 0.435f;
2434   screenCoordinates.y = stageSize.y * 0.52f;
2435   // hit expected, results changed
2436   DALI_TEST_CHECK( true == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2437   DALI_TEST_CHECK( results.actor  == offscreenActor );
2438   const Vector2 expectedCoordinates = (screenCoordinates-offset)/scale;
2439   DALI_TEST_EQUALS( expectedCoordinates , results.actorCoordinates, 0.1f, TEST_LOCATION );
2440
2441   screenCoordinates.x = stageSize.x * 0.65f;
2442   screenCoordinates.y = stageSize.y * 0.95f;
2443   // miss expected, results not changed
2444   DALI_TEST_CHECK( false == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2445   DALI_TEST_CHECK( results.actor  == offscreenActor );
2446   DALI_TEST_EQUALS( expectedCoordinates , results.actorCoordinates, 0.1f, TEST_LOCATION );
2447   END_TEST;
2448 }
2449
2450 int UtcDaliRenderTaskFinishInvisibleSourceActor(void)
2451 {
2452   TestApplication application;
2453
2454   tet_infoline("Testing RenderTask::SignalFinished()");
2455
2456   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2457   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2458
2459   CameraActor offscreenCameraActor = CameraActor::New();
2460
2461   Stage::GetCurrent().Add( offscreenCameraActor );
2462
2463   BufferImage image = BufferImage::New( 10, 10 );
2464   ImageActor rootActor = ImageActor::New( image );
2465   rootActor.SetSize( 10, 10 );
2466   rootActor.SetVisible(false);
2467   Stage::GetCurrent().Add( rootActor );
2468
2469   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2470   NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
2471   FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
2472
2473   // Flush all outstanding messages
2474   application.SendNotification();
2475   application.Render();
2476
2477   RenderTask newTask = taskList.CreateTask();
2478   newTask.SetCameraActor( offscreenCameraActor );
2479   newTask.SetSourceActor( rootActor );
2480   newTask.SetInputEnabled( false );
2481   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
2482   newTask.SetClearEnabled( true );
2483   newTask.SetExclusive( true );
2484   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
2485   newTask.SetTargetFrameBuffer( frameBufferImage );
2486
2487   // Framebuffer doesn't actually get created until Connected, i.e. by previous line
2488
2489   bool finished = false;
2490   RenderTaskFinished renderTaskFinished( finished );
2491   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2492
2493   // Flush the queue and render.
2494   application.SendNotification();
2495
2496   // 1 render to process render task, then wait for sync before finished msg is sent
2497   // from update to the event thread.
2498
2499   application.Render();
2500   application.SendNotification();
2501   DALI_TEST_CHECK( !finished );
2502
2503   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2504   DALI_TEST_CHECK( lastSyncObj != NULL );
2505
2506   application.Render();
2507   DALI_TEST_EQUALS( (application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
2508   application.SendNotification();
2509   DALI_TEST_CHECK( !finished );
2510
2511   application.Render();
2512   DALI_TEST_EQUALS( (application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
2513   application.SendNotification();
2514   DALI_TEST_CHECK( ! finished );
2515
2516   sync.SetObjectSynced( lastSyncObj, true );
2517
2518   application.Render();
2519   application.SendNotification();
2520   DALI_TEST_CHECK( !finished );
2521
2522   application.Render();
2523   application.SendNotification();
2524   DALI_TEST_CHECK( finished );
2525   finished = false;
2526
2527   application.Render(); // Double check no more finished signal
2528   application.SendNotification();
2529   DALI_TEST_CHECK( ! finished );
2530
2531   END_TEST;
2532 }