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

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