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

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