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

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