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