automated-tests/TET/dali-test-suite/render-tasks/utc-Dali-RenderTask.cpp

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