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

   1 /*
   2  * Copyright (c) 2017 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   END_TEST;
 761 }
 762
 763 int UtcDaliRenderTaskSetExclusive02(void)
 764 {
 765   TestApplication application;
 766
 767   tet_infoline("Testing RenderTask::SetExclusive() Check that changing from exclusive to not-exclusive works");
 768
 769   std::vector<GLuint> ids;
 770   ids.push_back( 8 ); // 8 = actor1
 771   application.GetGlAbstraction().SetNextTextureIds( ids );
 772
 773   BufferImage img1 = BufferImage::New( 1,1 );
 774   Actor actor1 = CreateRenderableActor( img1 );
 775   actor1.SetSize(1,1);
 776   Stage::GetCurrent().Add( actor1 );
 777
 778   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 779   RenderTask task = taskList.CreateTask();
 780
 781   task.SetSourceActor( actor1 );
 782   task.SetExclusive(true); // Actor should only render once
 783
 784   TestGlAbstraction& gl = application.GetGlAbstraction();
 785   TraceCallStack& drawTrace = gl.GetDrawTrace();
 786   drawTrace.Enable(true);
 787
 788   // Update & Render actor1
 789   application.SendNotification();
 790   application.Render();
 791
 792   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
 793
 794   // Set task to non-exclusive - actor1 should render twice:
 795   drawTrace.Reset();
 796   task.SetExclusive(false);
 797   application.SendNotification();
 798   application.Render();
 799
 800   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 2, TEST_LOCATION );
 801
 802   END_TEST;
 803 }
 804
 805 int UtcDaliRenderTaskSetExclusiveN(void)
 806 {
 807   TestApplication application;
 808
 809   tet_infoline("Testing RenderTask::SetExclusive() on empty handle");
 810
 811   RenderTask task;
 812   try
 813   {
 814     task.SetExclusive(true);
 815   }
 816   catch (Dali::DaliException& e)
 817   {
 818     DALI_TEST_PRINT_ASSERT( e );
 819     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
 820   }
 821   END_TEST;
 822 }
 823
 824 int UtcDaliRenderTaskIsExclusive01(void)
 825 {
 826   TestApplication application;
 827
 828   tet_infoline("Testing RenderTask::IsExclusive() Check default values are non-exclusive");
 829
 830   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 831
 832   // Not exclusive is the default
 833   RenderTask task = taskList.GetTask( 0u );
 834   DALI_TEST_CHECK( false == task.IsExclusive() );
 835
 836   RenderTask newTask = taskList.CreateTask();
 837   DALI_TEST_CHECK( false == newTask.IsExclusive() );
 838
 839   END_TEST;
 840 }
 841
 842 int UtcDaliRenderTaskIsExclusive02(void)
 843 {
 844   TestApplication application;
 845
 846   tet_infoline("Testing RenderTask::IsExclusive() Check the getter returns set values");
 847
 848   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 849
 850   // Not exclusive is the default
 851   RenderTask newTask = taskList.CreateTask();
 852   DALI_TEST_EQUALS( newTask.IsExclusive(), false, TEST_LOCATION );
 853
 854   newTask.SetExclusive(true);
 855   DALI_TEST_EQUALS( newTask.IsExclusive(), true, TEST_LOCATION );
 856   END_TEST;
 857 }
 858
 859 int UtcDaliRenderTaskIsExclusiveN(void)
 860 {
 861   TestApplication application;
 862
 863   tet_infoline("Testing RenderTask::IsExclusive() on empty handle");
 864
 865   RenderTask task;
 866   try
 867   {
 868     bool x = task.IsExclusive();
 869     (void) x;
 870   }
 871   catch (Dali::DaliException& e)
 872   {
 873     DALI_TEST_PRINT_ASSERT( e );
 874     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
 875   }
 876   END_TEST;
 877 }
 878
 879 int UtcDaliRenderTaskSetInputEnabled(void)
 880 {
 881   TestApplication application;
 882
 883   tet_infoline("Testing RenderTask::SetInputEnabled()");
 884
 885   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 886
 887   // Input is enabled by default
 888   RenderTask task = taskList.GetTask( 0u );
 889   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 890
 891   task.SetInputEnabled( false );
 892   DALI_TEST_CHECK( false == task.GetInputEnabled() );
 893
 894   task.SetInputEnabled( true );
 895   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 896   END_TEST;
 897 }
 898
 899 int UtcDaliRenderTaskGetInputEnabled(void)
 900 {
 901   TestApplication application;
 902
 903   tet_infoline("Testing RenderTask::GetInputEnabled()");
 904
 905   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 906
 907   // Input is enabled by default
 908   RenderTask task = taskList.GetTask( 0u );
 909   DALI_TEST_EQUALS( true, task.GetInputEnabled(), TEST_LOCATION );
 910
 911   RenderTask newTask = taskList.CreateTask();
 912   DALI_TEST_EQUALS( true, newTask.GetInputEnabled(), TEST_LOCATION );
 913
 914   newTask.SetInputEnabled(false);
 915   DALI_TEST_EQUALS( false, newTask.GetInputEnabled(), TEST_LOCATION );
 916
 917   END_TEST;
 918 }
 919
 920 int UtcDaliRenderTaskSetCameraActorP(void)
 921 {
 922   TestApplication application;
 923
 924   tet_infoline("Testing RenderTask::SetCameraActor()");
 925
 926   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 927
 928   RenderTask task = taskList.GetTask( 0u );
 929
 930   Actor defaultCameraActor = task.GetCameraActor();
 931   DALI_TEST_CHECK( defaultCameraActor );
 932
 933   CameraActor newCameraActor = CameraActor::New();
 934   DALI_TEST_CHECK( newCameraActor );
 935
 936   task.SetCameraActor( newCameraActor );
 937   DALI_TEST_CHECK( task.GetCameraActor() != defaultCameraActor );
 938   DALI_TEST_EQUALS( task.GetCameraActor(), newCameraActor, TEST_LOCATION );
 939   END_TEST;
 940 }
 941
 942
 943 int UtcDaliRenderTaskSetCameraActorN(void)
 944 {
 945   TestApplication application;
 946
 947   tet_infoline("Testing RenderTask::SetCameraActor() with empty actor handle");
 948
 949   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 950
 951   RenderTask task = taskList.GetTask( 0u );
 952
 953   Actor actor = task.GetCameraActor();
 954   DALI_TEST_CHECK( actor );
 955
 956   CameraActor cameraActor;
 957
 958   task.SetCameraActor( cameraActor );
 959   DALI_TEST_EQUALS( (bool)task.GetCameraActor(), false, TEST_LOCATION );
 960   DALI_TEST_EQUALS( task.GetCameraActor(), cameraActor, TEST_LOCATION );
 961   END_TEST;
 962 }
 963
 964
 965 int UtcDaliRenderTaskGetCameraActorP(void)
 966 {
 967   TestApplication application;
 968
 969   tet_infoline("Testing RenderTask::GetCameraActor()");
 970
 971   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 972
 973   RenderTask task = taskList.GetTask( 0u );
 974
 975   CameraActor actor = task.GetCameraActor();
 976   DALI_TEST_CHECK( actor );
 977   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
 978   DALI_TEST_GREATER( actor.GetFieldOfView(), 0.0f, TEST_LOCATION );
 979   END_TEST;
 980 }
 981
 982 int UtcDaliRenderTaskGetCameraActorN(void)
 983 {
 984   TestApplication application;
 985
 986   tet_infoline("Testing RenderTask::GetCameraActor() with empty handle");
 987   RenderTask task;
 988
 989   try
 990   {
 991     Actor actor = task.GetCameraActor();
 992   }
 993   catch (Dali::DaliException& e)
 994   {
 995     DALI_TEST_PRINT_ASSERT( e );
 996     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
 997   }
 998
 999   END_TEST;
1000 }
1001
1002 int UtcDaliRenderTaskSetTargetFrameBufferP(void)
1003 {
1004   TestApplication application;
1005
1006   tet_infoline("Testing RenderTask::SetTargetFrameBuffer()");
1007
1008   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1009
1010   RenderTask task = taskList.GetTask( 0u );
1011
1012   FrameBufferImage newImage = FrameBufferImage::New();
1013   task.SetTargetFrameBuffer( newImage );
1014   DALI_TEST_CHECK( task.GetTargetFrameBuffer() == newImage );
1015   END_TEST;
1016 }
1017
1018 int UtcDaliRenderTaskSetTargetFrameBufferN(void)
1019 {
1020   TestApplication application;
1021
1022   tet_infoline("Testing RenderTask::SetTargetFrameBuffer()");
1023
1024   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1025
1026   RenderTask task = taskList.GetTask( 0u );
1027   FrameBufferImage newImage; // Empty handle
1028   task.SetTargetFrameBuffer( newImage );
1029   DALI_TEST_EQUALS( (bool)task.GetTargetFrameBuffer(), false, TEST_LOCATION );
1030   END_TEST;
1031 }
1032
1033 int UtcDaliRenderTaskGetTargetFrameBufferP(void)
1034 {
1035   TestApplication application;
1036
1037   tet_infoline("Testing RenderTask::GetTargetFrameBuffer()");
1038
1039   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1040
1041   RenderTask newTask = taskList.CreateTask();
1042   FrameBufferImage fb = FrameBufferImage::New(128, 128, Pixel::RGBA8888);
1043   newTask.SetTargetFrameBuffer( fb );
1044   DALI_TEST_EQUALS( newTask.GetTargetFrameBuffer(), fb, TEST_LOCATION );
1045   END_TEST;
1046 }
1047
1048 int UtcDaliRenderTaskGetTargetFrameBufferN(void)
1049 {
1050   TestApplication application;
1051
1052   tet_infoline("Testing RenderTask::GetTargetFrameBuffer()");
1053
1054   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1055
1056   RenderTask task = taskList.GetTask( 0u );
1057
1058   // By default render-tasks do not render off-screen
1059   FrameBufferImage image = task.GetTargetFrameBuffer();
1060   DALI_TEST_CHECK( !image );
1061
1062   END_TEST;
1063 }
1064
1065 int UtcDaliRenderTaskSetFrameBufferP(void)
1066 {
1067   TestApplication application;
1068
1069   tet_infoline("Testing RenderTask::SetFrameBuffer()");
1070
1071   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1072
1073   RenderTask task = taskList.GetTask( 0u );
1074
1075   FrameBuffer newFrameBuffer = FrameBuffer::New( 128u, 128u, FrameBuffer::Attachment::NONE );
1076   task.SetFrameBuffer( newFrameBuffer );
1077   DALI_TEST_CHECK( task.GetFrameBuffer() == newFrameBuffer );
1078   END_TEST;
1079 }
1080
1081 int UtcDaliRenderTaskSetFrameBufferN(void)
1082 {
1083   TestApplication application;
1084
1085   tet_infoline("Testing RenderTask::SetFrameBuffer()");
1086
1087   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1088
1089   RenderTask task = taskList.GetTask( 0u );
1090   FrameBuffer newFrameBuffer; // Empty handle
1091   task.SetFrameBuffer( newFrameBuffer );
1092   DALI_TEST_EQUALS( (bool)task.GetFrameBuffer(), false, TEST_LOCATION );
1093   END_TEST;
1094 }
1095
1096 int UtcDaliRenderTaskGetFrameBufferP(void)
1097 {
1098   TestApplication application;
1099
1100   tet_infoline("Testing RenderTask::GetFrameBuffer()");
1101
1102   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1103
1104   RenderTask task = taskList.GetTask( 0u );
1105
1106   FrameBuffer newFrameBuffer = FrameBuffer::New( 1u, 1u, FrameBuffer::Attachment::NONE  );
1107   task.SetFrameBuffer( newFrameBuffer );
1108   DALI_TEST_CHECK( task.GetFrameBuffer() == newFrameBuffer );
1109   END_TEST;
1110 }
1111
1112 int UtcDaliRenderTaskGetFrameBufferN(void)
1113 {
1114   TestApplication application;
1115
1116   tet_infoline("Testing RenderTask::GetFrameBuffer()");
1117
1118   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1119
1120   RenderTask task = taskList.GetTask( 0u );
1121
1122   // A scene creates frame buffer by default
1123   FrameBuffer frameBuffer = task.GetFrameBuffer();
1124   DALI_TEST_CHECK( frameBuffer );
1125
1126   END_TEST;
1127 }
1128
1129 int UtcDaliRenderTaskSetScreenToFrameBufferFunctionP(void)
1130 {
1131   TestApplication application;
1132
1133   tet_infoline("Testing RenderTask::SetScreenToFrameBufferFunction()");
1134
1135   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1136
1137   RenderTask task = taskList.GetTask( 0u );
1138
1139   task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
1140
1141   Vector2 coordinates( 5, 10 );
1142   Vector2 convertedCoordinates( 6, 12 ); // + Vector(1, 2)
1143
1144   RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
1145   DALI_TEST_CHECK( func( coordinates ) );
1146   DALI_TEST_CHECK( coordinates == convertedCoordinates );
1147
1148   task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
1149   func = task.GetScreenToFrameBufferFunction();
1150   DALI_TEST_CHECK( func( coordinates ) );
1151
1152   task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
1153   func = task.GetScreenToFrameBufferFunction();
1154   DALI_TEST_CHECK( ! func( coordinates ) );
1155   END_TEST;
1156 }
1157
1158 int UtcDaliRenderTaskSetScreenToFrameBufferFunctionN(void)
1159 {
1160   TestApplication application;
1161
1162   tet_infoline("Testing RenderTask::SetScreenToFrameBufferFunction()");
1163
1164   RenderTask task; // Empty handle
1165   try
1166   {
1167     task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
1168   }
1169   catch (Dali::DaliException& e)
1170   {
1171     DALI_TEST_PRINT_ASSERT( e );
1172     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1173   }
1174   END_TEST;
1175 }
1176
1177 int UtcDaliRenderTaskGetScreenToFrameBufferFunctionP(void)
1178 {
1179   TestApplication application;
1180
1181   tet_infoline("Testing RenderTask::GetScreenToFrameBufferFunction()");
1182
1183   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1184
1185   RenderTask task = taskList.GetTask( 0u );
1186
1187   Vector2 originalCoordinates( 5, 10 );
1188   Vector2 coordinates( 5, 10 );
1189
1190   RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
1191   DALI_TEST_CHECK( !func( coordinates ) ); // conversion should fail by default
1192   DALI_TEST_CHECK( coordinates == originalCoordinates ); // coordinates should not be modified
1193   END_TEST;
1194 }
1195
1196 int UtcDaliRenderTaskGetScreenToFrameBufferFunctionN(void)
1197 {
1198   TestApplication application;
1199
1200   tet_infoline("Testing RenderTask::GetScreenToFrameBufferFunction() on empty handle");
1201
1202   RenderTask task;
1203   try
1204   {
1205     RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
1206     (void) func;
1207   }
1208   catch (Dali::DaliException& e)
1209   {
1210     DALI_TEST_PRINT_ASSERT( e );
1211     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1212   }
1213   END_TEST;
1214 }
1215
1216
1217 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorP(void)
1218 {
1219   TestApplication application;
1220   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor ");
1221
1222   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1223   RenderTask renderTask = taskList.CreateTask();
1224   Actor mappingActor = Actor::New();
1225   renderTask.SetScreenToFrameBufferMappingActor(mappingActor);
1226
1227   DALI_TEST_EQUALS( mappingActor, renderTask.GetScreenToFrameBufferMappingActor(), TEST_LOCATION );
1228   END_TEST;
1229 }
1230
1231
1232 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorN(void)
1233 {
1234   TestApplication application;
1235   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor with empty task handle");
1236
1237   RenderTask task;
1238   try
1239   {
1240     Actor mappingActor;
1241     task.SetScreenToFrameBufferMappingActor(mappingActor);
1242   }
1243   catch (Dali::DaliException& e)
1244   {
1245     DALI_TEST_PRINT_ASSERT( e );
1246     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1247   }
1248   END_TEST;
1249 }
1250
1251 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActor02N(void)
1252 {
1253   TestApplication application;
1254   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor with empty task handle");
1255
1256   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1257   RenderTask renderTask = taskList.CreateTask();
1258   Actor actor;
1259   renderTask.SetScreenToFrameBufferMappingActor(actor);
1260
1261   DALI_TEST_EQUALS( (bool)renderTask.GetScreenToFrameBufferMappingActor(), false, TEST_LOCATION);
1262   END_TEST;
1263 }
1264
1265 int UtcDaliRenderTaskGetViewportP01(void)
1266 {
1267   TestApplication application;
1268
1269   tet_infoline("Testing RenderTask::GetViewport() on default task");
1270
1271   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1272   RenderTask task = taskList.GetTask( 0u );
1273   Viewport viewport = task.GetViewport();
1274
1275   // By default the viewport should match the stage width/height
1276   Vector2 stageSize = Stage::GetCurrent().GetSize();
1277   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1278   DALI_TEST_CHECK( viewport == expectedViewport );
1279   END_TEST;
1280 }
1281
1282 int UtcDaliRenderTaskGetViewportP02(void)
1283 {
1284   TestApplication application;
1285
1286   tet_infoline("Testing RenderTask::GetViewport() on new task");
1287
1288   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1289   RenderTask task = taskList.CreateTask();
1290   Viewport viewport = task.GetViewport();
1291
1292   // By default the viewport should match the stage width/height
1293   Vector2 stageSize = Stage::GetCurrent().GetSize();
1294   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1295   DALI_TEST_CHECK( viewport == expectedViewport );
1296   END_TEST;
1297 }
1298
1299 int UtcDaliRenderTaskGetViewportN(void)
1300 {
1301   TestApplication application;
1302
1303   tet_infoline("Testing RenderTask::GetViewport() on empty handle");
1304
1305   RenderTask task;
1306   try
1307   {
1308     Viewport viewport = task.GetViewport();
1309     (void) viewport;
1310   }
1311   catch (Dali::DaliException& e)
1312   {
1313     DALI_TEST_PRINT_ASSERT( e );
1314     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1315   }
1316   END_TEST;
1317 }
1318
1319
1320 int UtcDaliRenderTaskSetViewportP(void)
1321 {
1322   TestApplication application;
1323
1324   tet_infoline("Testing RenderTask::SetViewport()");
1325
1326   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1327
1328   RenderTask task = taskList.GetTask( 0u );
1329   Vector2 stageSize = Stage::GetCurrent().GetSize();
1330   Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
1331   task.SetViewport( newViewport );
1332
1333   // Update (viewport is a property)
1334   application.SendNotification();
1335   application.Render();
1336
1337   DALI_TEST_CHECK( task.GetViewport() == newViewport );
1338   END_TEST;
1339 }
1340
1341 int UtcDaliRenderTaskSetViewportN(void)
1342 {
1343   TestApplication application;
1344
1345   tet_infoline("Testing RenderTask::SetViewport()");
1346
1347   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1348
1349   RenderTask task;
1350   try
1351   {
1352     Vector2 stageSize = Stage::GetCurrent().GetSize();
1353     Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
1354     task.SetViewport( newViewport );
1355   }
1356   catch (Dali::DaliException& e)
1357   {
1358     DALI_TEST_PRINT_ASSERT( e );
1359     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1360   }
1361
1362   END_TEST;
1363 }
1364
1365
1366 int UtcDaliRenderTaskSetViewportPosition(void)
1367 {
1368   TestApplication application;
1369
1370   tet_infoline("Testing RenderTask::SetViewportPosition()");
1371
1372   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1373
1374   RenderTask task = taskList.GetTask( 0u );
1375
1376   Viewport viewport = task.GetViewport();
1377
1378   // By default the viewport should match the stage width/height
1379
1380   Vector2 stageSize = Stage::GetCurrent().GetSize();
1381   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1382   DALI_TEST_CHECK( viewport == expectedViewport );
1383
1384   // 'Setter' test
1385   Vector2 newPosition(25.0f, 50.0f);
1386   task.SetViewportPosition( newPosition );
1387
1388   // Update (viewport is a property)
1389   application.SendNotification();
1390   application.Render();
1391
1392   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1393
1394   // Set by Property test
1395   Vector2 newPosition2(32.0f, 32.0f);
1396   task.SetProperty( RenderTask::Property::VIEWPORT_POSITION, newPosition2 );
1397   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
1398   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition, TEST_LOCATION ); // still the old position
1399
1400   // Update
1401   application.SendNotification();
1402   application.Render();
1403
1404   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1405   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
1406   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
1407
1408   Vector2 newPosition3(64.0f, 0.0f);
1409   Animation animation = Animation::New(1.0f);
1410   animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_POSITION ), newPosition3, AlphaFunction::LINEAR );
1411   animation.Play();
1412
1413   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1414   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
1415
1416   // Perform 1000ms worth of updates at which point animation should have completed.
1417   Wait(application, 1000);
1418   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1419   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1420   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1421
1422   // Create another animation which animates by a certain value
1423   const Vector2 newPosition4( 75.0f, 45.0f );
1424   const Vector2 relativePosition( newPosition4 - newPosition3 );
1425   animation = Animation::New( 1.0f );
1426   animation.AnimateBy( Property( task, RenderTask::Property::VIEWPORT_POSITION ), relativePosition );
1427   animation.Play();
1428
1429   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1430   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, TEST_LOCATION );
1431
1432   // Perform 1000ms worth of updates at which point animation should have completed.
1433   Wait(application, 1000);
1434   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1435   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1436   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1437
1438   END_TEST;
1439 }
1440
1441 int UtcDaliRenderTaskSetViewportSize(void)
1442 {
1443   TestApplication application;
1444
1445   tet_infoline("Testing RenderTask::SetViewportSize()");
1446
1447   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1448
1449   RenderTask task = taskList.GetTask( 0u );
1450
1451   Viewport viewport = task.GetViewport();
1452
1453   // By default the viewport should match the stage width/height
1454
1455   Vector2 stageSize = Stage::GetCurrent().GetSize();
1456   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1457   DALI_TEST_CHECK( viewport == expectedViewport );
1458
1459   Vector2 newSize(128.0f, 64.0f);
1460   task.SetViewportSize( newSize );
1461
1462   // Update (viewport is a property)
1463   application.SendNotification();
1464   application.Render();
1465
1466   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1467
1468   // Set by Property test
1469   Vector2 newSize2(50.0f, 50.0f);
1470   task.SetProperty( RenderTask::Property::VIEWPORT_SIZE, newSize2 );
1471   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
1472   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize, TEST_LOCATION ); // still the old position
1473
1474   // Update
1475   application.SendNotification();
1476   application.Render();
1477
1478   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1479   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
1480   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
1481
1482   Vector2 newSize3(10.0f, 10.0f);
1483   Animation animation = Animation::New(1.0f);
1484   animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_SIZE ), newSize3, AlphaFunction::LINEAR );
1485   animation.Play();
1486
1487   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE  ), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1488   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
1489
1490   // Perform 1000ms worth of updates at which point animation should have completed.
1491   Wait(application, 1000);
1492   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1493   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1494   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE  ), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1495
1496   // Create another animation which animates by a certain value
1497   const Vector2 newSize4( 75.0f, 45.0f );
1498   const Vector2 relativeSize( newSize4 - newSize3 );
1499   animation = Animation::New( 1.0f );
1500   animation.AnimateBy( Property( task, RenderTask::Property::VIEWPORT_SIZE ), relativeSize );
1501   animation.Play();
1502
1503   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1504   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize3, TEST_LOCATION );
1505
1506   // Perform 1000ms worth of updates at which point animation should have completed.
1507   Wait(application, 1000);
1508   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1509   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1510   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1511
1512   END_TEST;
1513 }
1514
1515 int UtcDaliRenderTaskSetClearColorP(void)
1516 {
1517   TestApplication application;
1518
1519   tet_infoline("Testing RenderTask::SetClearColor()");
1520
1521   Vector4 testColor( 1.0f, 2.0f, 3.0f, 4.0f );
1522   Vector4 testColor2( 5.0f, 6.0f, 7.0f, 8.0f );
1523
1524   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1525
1526   RenderTask task = taskList.GetTask( 0u );
1527   DALI_TEST_CHECK( task.GetClearColor() != testColor );
1528
1529   task.SetClearColor( testColor );
1530
1531   // Wait a frame.
1532   Wait(application);
1533
1534   DALI_TEST_EQUALS( task.GetClearColor(), testColor, TEST_LOCATION );
1535
1536   task.SetProperty( RenderTask::Property::CLEAR_COLOR, testColor2 );
1537   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
1538   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor, TEST_LOCATION ); // still the old color
1539
1540   // Wait a frame.
1541   Wait(application);
1542
1543   DALI_TEST_EQUALS( task.GetClearColor(), testColor2, TEST_LOCATION );
1544   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
1545   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
1546
1547   Vector4 newColor3(10.0f, 10.0f, 20.0f, 30.0f);
1548   Animation animation = Animation::New(1.0f);
1549   animation.AnimateTo( Property( task, RenderTask::Property::CLEAR_COLOR ), newColor3, AlphaFunction::LINEAR );
1550   animation.Play();
1551
1552   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR  ), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1553   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
1554
1555   // Perform 1000ms worth of updates at which point animation should have completed.
1556   Wait(application, 1000);
1557   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1558   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR  ), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1559
1560   // Create another animation which animates by a certain value
1561   const Vector4 newColor4( 0.45f, 0.35f, 0.25f, 0.1f );
1562   const Vector4 relativeColor( newColor4 - newColor3 );
1563   animation = Animation::New( 1.0f );
1564   animation.AnimateBy( Property( task, RenderTask::Property::CLEAR_COLOR ), relativeColor );
1565   animation.Play();
1566
1567   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION );
1568   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor3, Math::MACHINE_EPSILON_10, TEST_LOCATION );
1569
1570   // Perform 1000ms worth of updates at which point animation should have completed.
1571   Wait(application, 1000);
1572   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION );
1573   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION );
1574
1575   END_TEST;
1576 }
1577
1578 int UtcDaliRenderTaskSetClearColorN(void)
1579 {
1580   TestApplication application;
1581
1582   tet_infoline("Testing RenderTask::SetClearColor() on empty handle");
1583
1584   RenderTask task;
1585   try
1586   {
1587     task.SetClearColor( Vector4::ZERO );
1588   }
1589   catch (Dali::DaliException& e)
1590   {
1591     DALI_TEST_PRINT_ASSERT( e );
1592     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1593   }
1594   END_TEST;
1595 }
1596
1597 int UtcDaliRenderTaskGetClearColorP(void)
1598 {
1599   TestApplication application;
1600
1601   tet_infoline("Testing RenderTask::GetClearColor()");
1602
1603   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1604   RenderTask task = taskList.GetTask( 0u );
1605   DALI_TEST_EQUALS( task.GetClearColor(), RenderTask::DEFAULT_CLEAR_COLOR, TEST_LOCATION );
1606   END_TEST;
1607 }
1608
1609 int UtcDaliRenderTaskGetClearColorN(void)
1610 {
1611   TestApplication application;
1612
1613   tet_infoline("Testing RenderTask::GetClearColor()");
1614
1615   RenderTask task;
1616   try
1617   {
1618     Vector4 color = task.GetClearColor();
1619     (void) color;
1620   }
1621   catch (Dali::DaliException& e)
1622   {
1623     DALI_TEST_PRINT_ASSERT( e );
1624     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1625   }
1626   END_TEST;
1627 }
1628
1629 int UtcDaliRenderTaskSetClearEnabledP(void)
1630 {
1631   TestApplication application;
1632
1633   tet_infoline("Testing RenderTask::SetClearEnabled()");
1634
1635   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1636
1637   RenderTask task = taskList.GetTask( 0u );
1638   DALI_TEST_CHECK( !task.GetClearEnabled() ); // defaults to false
1639
1640   task.SetClearEnabled( true );
1641   DALI_TEST_EQUALS( task.GetClearEnabled(), true, TEST_LOCATION );
1642
1643   task.SetClearEnabled( false );
1644   DALI_TEST_EQUALS( task.GetClearEnabled(), false, TEST_LOCATION );
1645   END_TEST;
1646 }
1647
1648 int UtcDaliRenderTaskSetClearEnabledN(void)
1649 {
1650   TestApplication application;
1651
1652   tet_infoline("Testing RenderTask::SetClearEnabled() with empty handle");
1653
1654   RenderTask task;
1655   try
1656   {
1657     task.SetClearEnabled(true);
1658   }
1659   catch (Dali::DaliException& e)
1660   {
1661     DALI_TEST_PRINT_ASSERT( e );
1662     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1663   }
1664   END_TEST;
1665 }
1666
1667 int UtcDaliRenderTaskGetClearEnabledP(void)
1668 {
1669   TestApplication application;
1670
1671   tet_infoline("Testing RenderTask::GetClearEnabled()");
1672
1673   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1674
1675   RenderTask task = taskList.GetTask( 0u );
1676   DALI_TEST_CHECK( !task.GetClearEnabled() ); // defaults to false
1677   END_TEST;
1678 }
1679
1680
1681 int UtcDaliRenderTaskGetClearEnabledN(void)
1682 {
1683   TestApplication application;
1684
1685   tet_infoline("Testing RenderTask::GetClearEnabled() with empty handle");
1686
1687   RenderTask task;
1688   try
1689   {
1690     bool x = task.GetClearEnabled();
1691     (void) x;
1692   }
1693   catch (Dali::DaliException& e)
1694   {
1695     DALI_TEST_PRINT_ASSERT( e );
1696     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1697   }
1698   END_TEST;
1699 }
1700
1701 int UtcDaliRenderTaskSetCullModeP(void)
1702 {
1703   TestApplication application;
1704
1705   tet_infoline("Testing RenderTask::SetCullMode()");
1706
1707   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1708   RenderTask task = taskList.GetTask( 0u );
1709   DALI_TEST_EQUALS( task.GetCullMode(), true, TEST_LOCATION );
1710
1711   task.SetCullMode( false );
1712
1713   DALI_TEST_EQUALS( task.GetCullMode(), false, TEST_LOCATION );
1714
1715   END_TEST;
1716 }
1717
1718 int UtcDaliRenderTaskSetCullModeN(void)
1719 {
1720   TestApplication application;
1721
1722   tet_infoline("Testing RenderTask::SetCullMode() on empty handle");
1723
1724   RenderTask task;
1725   try
1726   {
1727     task.SetCullMode( false );
1728   }
1729   catch (Dali::DaliException& e)
1730   {
1731     DALI_TEST_PRINT_ASSERT( e );
1732     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1733   }
1734   END_TEST;
1735 }
1736
1737 int UtcDaliRenderTaskGetCullModeP(void)
1738 {
1739   TestApplication application;
1740
1741   tet_infoline("Testing RenderTask::GetCullMode()");
1742
1743   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1744   RenderTask task = taskList.GetTask( 0u );
1745   DALI_TEST_EQUALS( task.GetCullMode(), true, TEST_LOCATION );
1746   END_TEST;
1747 }
1748
1749 int UtcDaliRenderTaskGetCullModeN(void)
1750 {
1751   TestApplication application;
1752
1753   tet_infoline("Testing RenderTask::GetCullMode() with empty handle");
1754
1755   RenderTask task;
1756   try
1757   {
1758     bool x = task.GetCullMode();
1759     (void) x;
1760   }
1761   catch (Dali::DaliException& e)
1762   {
1763     DALI_TEST_PRINT_ASSERT( e );
1764     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1765   }
1766   END_TEST;
1767 }
1768
1769
1770 int UtcDaliRenderTaskSetRefreshRate(void)
1771 {
1772   TestApplication application;
1773
1774   tet_infoline("Testing RenderTask::SetRefreshRate()");
1775
1776   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1777
1778   // By default tasks will be processed every frame
1779   RenderTask task = taskList.GetTask( 0u );
1780   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1781
1782   task.SetRefreshRate( 2u ); // every-other frame
1783   DALI_TEST_CHECK( 2u == task.GetRefreshRate() );
1784
1785   task.SetRefreshRate( RenderTask::REFRESH_ALWAYS );
1786   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1787   END_TEST;
1788 }
1789
1790 int UtcDaliRenderTaskGetRefreshRate(void)
1791 {
1792   TestApplication application;
1793
1794   tet_infoline("Testing RenderTask::GetRefreshRate()");
1795
1796   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1797
1798   // By default tasks will be processed every frame
1799   RenderTask task = taskList.GetTask( 0u );
1800   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1801
1802   RenderTask newTask = taskList.CreateTask();
1803   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == newTask.GetRefreshRate() );
1804   END_TEST;
1805 }
1806
1807 int UtcDaliRenderTaskSignalFinished(void)
1808 {
1809   TestApplication application;
1810
1811   tet_infoline("Testing RenderTask::SignalFinished()");
1812
1813   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1814   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1815
1816   CameraActor offscreenCameraActor = CameraActor::New();
1817
1818   Stage::GetCurrent().Add( offscreenCameraActor );
1819
1820   BufferImage image = BufferImage::New( 10, 10 );
1821   image.Update();
1822   Actor rootActor = CreateRenderableActor( image );
1823   rootActor.SetSize( 10, 10 );
1824   Stage::GetCurrent().Add( rootActor );
1825
1826   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1827   NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
1828   FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
1829
1830   RenderTask newTask = taskList.CreateTask();
1831   newTask.SetCameraActor( offscreenCameraActor );
1832   newTask.SetSourceActor( rootActor );
1833   newTask.SetInputEnabled( false );
1834   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
1835   newTask.SetClearEnabled( true );
1836   newTask.SetExclusive( true );
1837   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
1838   newTask.SetTargetFrameBuffer( frameBufferImage );
1839   newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, true );
1840
1841   bool finished = false;
1842   RenderTaskFinished renderTaskFinished( finished );
1843   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1844
1845   // Flush the queue and render.
1846   application.SendNotification();
1847
1848   // 1 render to process render task, then wait for sync before finished msg is sent
1849   // from update to the event thread.
1850
1851   application.Render();
1852   application.SendNotification();
1853   DALI_TEST_CHECK( !finished );
1854
1855   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1856   DALI_TEST_CHECK( lastSyncObj != NULL );
1857
1858   application.Render();
1859   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
1860   application.SendNotification();
1861   DALI_TEST_CHECK( !finished );
1862
1863   application.Render();
1864   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
1865   application.SendNotification();
1866   DALI_TEST_CHECK( ! finished );
1867
1868   sync.SetObjectSynced( lastSyncObj, true );
1869
1870   application.Render();
1871   application.SendNotification();
1872   DALI_TEST_CHECK( !finished );
1873
1874   application.Render();
1875   application.SendNotification();
1876   DALI_TEST_CHECK( finished );
1877
1878   DALI_TEST_EQUALS( application.GetUpdateStatus(), 0, TEST_LOCATION );
1879   END_TEST;
1880 }
1881
1882
1883 int UtcDaliRenderTaskContinuous01(void)
1884 {
1885   TestApplication application;
1886
1887   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not staged)\nPOST:continuous renders, no Finished signal");
1888
1889   // SETUP AN OFFSCREEN RENDER TASK
1890   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1891   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1892   drawTrace.Enable(true);
1893
1894   Actor rootActor = Actor::New();
1895   Stage::GetCurrent().Add( rootActor );
1896
1897   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
1898   Stage::GetCurrent().Add( offscreenCameraActor );
1899
1900   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
1901
1902   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1903   bool finished = false;
1904   RenderTaskFinished renderTaskFinished( finished );
1905   application.SendNotification();
1906
1907   // START PROCESS/RENDER                     Input,    Expected  Input, Expected, KeepUpdating
1908   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, false,   finished, false, false, __LINE__ ) );
1909   application.GetPlatform().ClearReadyResources();
1910
1911   // ADD SOURCE ACTOR TO STAGE - expect continuous renders to start, no finished signal
1912   Stage::GetCurrent().Add(secondRootActor);
1913   application.SendNotification();
1914
1915   // CONTINUE PROCESS/RENDER                  Input,    Expected  Input,    Expected
1916   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, true,    finished, false, false, __LINE__ ) );
1917   END_TEST;
1918 }
1919
1920
1921 int UtcDaliRenderTaskContinuous02(void)
1922 {
1923   TestApplication application;
1924
1925   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not visible)\nPOST:continuous renders, no Finished signal");
1926
1927   // SETUP AN OFFSCREEN RENDER TASK
1928   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1929   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1930   drawTrace.Enable(true);
1931
1932   Actor rootActor = Actor::New();
1933   Stage::GetCurrent().Add( rootActor );
1934
1935   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
1936   Stage::GetCurrent().Add( offscreenCameraActor );
1937
1938   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
1939   Stage::GetCurrent().Add(secondRootActor);
1940   secondRootActor.SetVisible(false);
1941
1942   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1943   bool finished = false;
1944   RenderTaskFinished renderTaskFinished( finished );
1945   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1946   application.SendNotification();
1947
1948   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected, KeepUpdating
1949   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false, __LINE__ ) );
1950   application.GetPlatform().ClearReadyResources();
1951
1952   // MAKE SOURCE ACTOR VISIBLE - expect continuous renders to start, no finished signal
1953   secondRootActor.SetVisible(true);
1954   application.SendNotification();
1955
1956   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
1957   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
1958   END_TEST;
1959 }
1960
1961 int UtcDaliRenderTaskContinuous03(void)
1962 {
1963   TestApplication application;
1964
1965   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (camera actor not staged)\nPOST:continuous renders, no Finished signal");
1966
1967   // SETUP AN OFFSCREEN RENDER TASK
1968   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1969   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1970   drawTrace.Enable(true);
1971
1972   Actor rootActor = Actor::New();
1973   Stage::GetCurrent().Add( rootActor );
1974
1975   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
1976   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
1977   Stage::GetCurrent().Add(secondRootActor);
1978
1979   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1980   bool finished = false;
1981   RenderTaskFinished renderTaskFinished( finished );
1982   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1983   application.SendNotification();
1984
1985   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1986   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false, __LINE__ ) );
1987   application.GetPlatform().ClearReadyResources();
1988
1989   // ADD CAMERA ACTOR TO STAGE - expect continuous renders to start, no finished signal
1990   Stage::GetCurrent().Add( offscreenCameraActor );
1991   application.SendNotification();
1992
1993   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
1994   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
1995   END_TEST;
1996 }
1997
1998
1999 int UtcDaliRenderTaskContinuous04(void)
2000 {
2001   TestApplication application;
2002
2003   tet_infoline("Testing RenderTask Render Continuous using loaded image");
2004
2005   // SETUP AN OFFSCREEN RENDER TASK
2006   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2007   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2008   drawTrace.Enable(true);
2009
2010   Actor rootActor = Actor::New();
2011   Stage::GetCurrent().Add( rootActor );
2012
2013   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2014   Stage::GetCurrent().Add( offscreenCameraActor );
2015   Actor secondRootActor = CreateRenderableActorFailed(application, "aFile.jpg");
2016   Stage::GetCurrent().Add(secondRootActor);
2017
2018   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2019   bool finished = false;
2020   RenderTaskFinished renderTaskFinished( finished );
2021   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2022   application.SendNotification();
2023
2024   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2025   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, false, __LINE__ ) );
2026   END_TEST;
2027 }
2028
2029 int UtcDaliRenderTaskOnce01(void)
2030 {
2031   TestApplication application;
2032
2033   tet_infoline("Testing RenderTask Render Once GlSync, using loaded image");
2034
2035   // SETUP AN OFFSCREEN RENDER TASK
2036   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2037   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2038   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2039   drawTrace.Enable(true);
2040
2041   Actor rootActor = Actor::New();
2042   Stage::GetCurrent().Add( rootActor );
2043
2044   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2045   Stage::GetCurrent().Add( offscreenCameraActor );
2046   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2047
2048   Stage::GetCurrent().Add(secondRootActor);
2049
2050   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
2051   bool finished = false;
2052   RenderTaskFinished renderTaskFinished( finished );
2053   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2054   application.SendNotification();
2055
2056   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true, __LINE__  ) );
2057
2058   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2059   DALI_TEST_CHECK( lastSyncObj != NULL );
2060   sync.SetObjectSynced( lastSyncObj, true );
2061
2062   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true, __LINE__  ) );
2063   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__  ) );
2064   END_TEST;
2065 }
2066
2067 int UtcDaliRenderTaskOnce02(void)
2068 {
2069   TestApplication application;
2070
2071   tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loaded image.\n");
2072
2073   // SETUP AN OFFSCREEN RENDER TASK
2074   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2075   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2076   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2077   drawTrace.Enable(true);
2078
2079   Actor rootActor = Actor::New();
2080   Stage::GetCurrent().Add( rootActor );
2081
2082   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2083   Stage::GetCurrent().Add( offscreenCameraActor );
2084
2085   Shader shader = CreateShader();
2086   Image image = CreateResourceImage(application, "aFile.jpg");
2087   TextureSet textureSet = CreateTextureSet( image );
2088
2089   Geometry geometry = CreateQuadGeometry();
2090   Renderer renderer = Renderer::New(geometry, shader);
2091   renderer.SetTextures( textureSet );
2092   Actor secondRootActor = Actor::New();
2093   secondRootActor.AddRenderer(renderer);
2094   secondRootActor.SetSize(100, 100);
2095   Stage::GetCurrent().Add(secondRootActor);
2096
2097   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
2098   bool finished = false;
2099   RenderTaskFinished renderTaskFinished( finished );
2100   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2101   application.SendNotification();
2102
2103   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true, __LINE__  ) );
2104
2105   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2106   DALI_TEST_CHECK( lastSyncObj != NULL );
2107   sync.SetObjectSynced( lastSyncObj, true );
2108
2109   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true, __LINE__  ) );
2110   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__  ) );
2111
2112    END_TEST;
2113 }
2114
2115 int UtcDaliRenderTaskOnce03(void)
2116 {
2117   TestApplication application;
2118
2119   tet_infoline("Testing RenderTask Render Once GlSync, using loaded image. Switch from render always after ready to render once\n");
2120
2121   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2122   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2123   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2124   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2125   drawTrace.Enable(true);
2126
2127   Actor rootActor = Actor::New();
2128   Stage::GetCurrent().Add( rootActor );
2129
2130   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2131   Stage::GetCurrent().Add( offscreenCameraActor );
2132   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2133   Stage::GetCurrent().Add(secondRootActor);
2134
2135   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2136   bool finished = false;
2137   RenderTaskFinished renderTaskFinished( finished );
2138   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2139   application.SendNotification();
2140
2141   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2142
2143   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2144   application.SendNotification();
2145
2146   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true, __LINE__  ) );
2147
2148   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2149   DALI_TEST_CHECK( lastSyncObj != NULL );
2150   sync.SetObjectSynced( lastSyncObj, true );
2151
2152   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true, __LINE__  ) );
2153   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__  ) );
2154
2155   END_TEST;
2156 }
2157
2158
2159 int UtcDaliRenderTaskOnce04(void)
2160 {
2161   TestApplication application;
2162   tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loaded image.\n"
2163                "Switch from render always after ready to render once\n"
2164               );
2165
2166   // SETUP AN OFFSCREEN RENDER TASK
2167   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2168   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2169   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2170   drawTrace.Enable(true);
2171
2172   Actor rootActor = Actor::New();
2173   Stage::GetCurrent().Add( rootActor );
2174
2175   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2176   Stage::GetCurrent().Add( offscreenCameraActor );
2177
2178   Shader shader = CreateShader();
2179   Image image = CreateResourceImage(application, "aFile.jpg");
2180   TextureSet textureSet = CreateTextureSet( image );
2181
2182   Geometry geometry = CreateQuadGeometry();
2183   Renderer renderer = Renderer::New(geometry, shader);
2184   renderer.SetTextures( textureSet );
2185   Actor secondRootActor = Actor::New();
2186   secondRootActor.AddRenderer(renderer);
2187   secondRootActor.SetSize(100, 100);
2188   Stage::GetCurrent().Add(secondRootActor);
2189
2190   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2191   bool finished = false;
2192   RenderTaskFinished renderTaskFinished( finished );
2193   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2194   application.SendNotification();
2195
2196   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2197
2198   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2199   application.SendNotification();
2200
2201   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true, __LINE__  ) );
2202
2203   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2204   DALI_TEST_CHECK( lastSyncObj != NULL );
2205   sync.SetObjectSynced( lastSyncObj, true );
2206
2207   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true, __LINE__  ) );
2208   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__  ) );
2209
2210   END_TEST;
2211 }
2212
2213 int UtcDaliRenderTaskOnceNoSync01(void)
2214 {
2215   TestApplication application;
2216
2217   tet_infoline("Testing RenderTask Render Once, \nPRE: Resources ready\nPOST: Finished signal sent once only");
2218
2219   // SETUP AN OFFSCREEN RENDER TASK
2220   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2221   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2222   drawTrace.Enable(true);
2223
2224   Actor rootActor = Actor::New();
2225   Stage::GetCurrent().Add( rootActor );
2226
2227   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2228   Stage::GetCurrent().Add( offscreenCameraActor );
2229   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2230   Stage::GetCurrent().Add(secondRootActor);
2231
2232   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2233   bool finished = false;
2234   RenderTaskFinished renderTaskFinished( finished );
2235   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2236   application.SendNotification();
2237
2238   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true, __LINE__ ) );
2239   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__ ) );
2240   END_TEST;
2241 }
2242
2243 int UtcDaliRenderTaskOnceNoSync02(void)
2244 {
2245   TestApplication application;
2246
2247   tet_infoline("Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loaded image.\n"
2248                "PRE: Resources ready\nPOST: Finished signal sent once only");
2249   // SETUP AN OFFSCREEN RENDER TASK
2250   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2251   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2252   drawTrace.Enable(true);
2253
2254   Actor rootActor = Actor::New();
2255   Stage::GetCurrent().Add( rootActor );
2256
2257   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2258   Stage::GetCurrent().Add( offscreenCameraActor );
2259
2260   Shader shader = CreateShader();
2261   Image image = CreateResourceImage(application, "aFile.jpg");
2262   TextureSet textureSet = CreateTextureSet( image );
2263
2264   Geometry geometry = CreateQuadGeometry();
2265   Renderer renderer = Renderer::New(geometry, shader);
2266   renderer.SetTextures( textureSet );
2267   Actor secondRootActor = Actor::New();
2268   secondRootActor.AddRenderer(renderer);
2269   secondRootActor.SetSize(100, 100);
2270   Stage::GetCurrent().Add(secondRootActor);
2271
2272   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2273   bool finished = false;
2274   RenderTaskFinished renderTaskFinished( finished );
2275   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2276   application.SendNotification();
2277
2278   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true, __LINE__ ) );
2279   application.GetPlatform().ClearReadyResources();
2280   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__ ) );
2281
2282   END_TEST;
2283 }
2284
2285 int UtcDaliRenderTaskOnceNoSync03(void)
2286 {
2287   TestApplication application;
2288
2289   tet_infoline("Testing RenderTask Render Once, using loaded image. Switch from render always after ready to render once\n"
2290                "PRE: Render task ready, Image loaded\n"
2291                "POST: Finished signal sent only once");
2292
2293   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2294   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2295   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2296   drawTrace.Enable(true);
2297
2298   Actor rootActor = Actor::New();
2299   Stage::GetCurrent().Add( rootActor );
2300
2301   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2302   Stage::GetCurrent().Add( offscreenCameraActor );
2303   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2304   Stage::GetCurrent().Add(secondRootActor);
2305
2306   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2307   bool finished = false;
2308   RenderTaskFinished renderTaskFinished( finished );
2309   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2310   application.SendNotification();
2311
2312   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2313
2314   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2315   application.SendNotification(); //         Input,    Expected  Input,    Expected
2316   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true, __LINE__ ) );
2317   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__ ) );
2318   END_TEST;
2319 }
2320
2321 int UtcDaliRenderTaskOnceNoSync04(void)
2322 {
2323   TestApplication application;
2324
2325   tet_infoline("Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loading image.\n"
2326                "Switch from render always after ready to render once\n"
2327                "PRE: Render task ready, Image not loaded\n"
2328                "POST: Finished signal sent only once");
2329
2330   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2331   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2332   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2333   drawTrace.Enable(true);
2334
2335   Actor rootActor = Actor::New();
2336   Stage::GetCurrent().Add( rootActor );
2337
2338   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2339   Stage::GetCurrent().Add( offscreenCameraActor );
2340
2341   Shader shader = CreateShader();
2342   Image image = CreateResourceImage(application, "aFile.jpg");
2343   TextureSet textureSet = CreateTextureSet( image );
2344
2345   Geometry geometry = CreateQuadGeometry();
2346   Renderer renderer = Renderer::New(geometry, shader);
2347   renderer.SetTextures( textureSet );
2348   Actor secondRootActor = Actor::New();
2349   secondRootActor.AddRenderer(renderer);
2350   secondRootActor.SetSize(100, 100);
2351   Stage::GetCurrent().Add(secondRootActor);
2352
2353
2354   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2355   bool finished = false;
2356   RenderTaskFinished renderTaskFinished( finished );
2357   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2358   application.SendNotification();
2359
2360   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2361   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2362   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2363   DALI_TEST_CHECK( lastSyncObj == NULL );
2364
2365   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2366   application.SendNotification(); //         Input,    Expected  Input,    Expected
2367   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true, __LINE__ ) );
2368   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__ ) );
2369
2370   lastSyncObj = sync.GetLastSyncObject();
2371   DALI_TEST_CHECK( lastSyncObj == NULL );
2372
2373   END_TEST;
2374 }
2375
2376 int UtcDaliRenderTaskOnceNoSync05(void)
2377 {
2378   TestApplication application;
2379
2380   tet_infoline("Testing RenderTask Render Once\n"
2381                "SetRefreshRate(ONCE), resource load failed, completes render task.\n"
2382                "PRE: resources failed to load\n"
2383                "POST: No finished signal sent.");
2384
2385   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2386   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2387   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2388   drawTrace.Enable(true);
2389
2390   Actor rootActor = Actor::New();
2391   Stage::GetCurrent().Add( rootActor );
2392
2393   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2394   Stage::GetCurrent().Add( offscreenCameraActor );
2395   Actor secondRootActor = CreateRenderableActorFailed(application, "aFile.jpg");
2396   Stage::GetCurrent().Add(secondRootActor);
2397
2398   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2399   bool finished = false;
2400   RenderTaskFinished renderTaskFinished( finished );
2401   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2402   application.SendNotification();
2403
2404   // START PROCESS/RENDER                    Input,     Expected  Input,    Expected
2405   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2406
2407   // CHANGE TO RENDER ONCE,
2408   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2409   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2410
2411   END_TEST;
2412 }
2413
2414
2415
2416 int UtcDaliRenderTaskOnceChain01(void)
2417 {
2418   TestApplication application;
2419
2420   tet_infoline("Testing RenderTask Render Once Chained render tasks\n"
2421                "SetRefreshRate(ONCE), resource load completes, both render tasks render.\n"
2422                "PRE: resources ready\n"
2423                "POST: 2 finished signals sent.");
2424
2425   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2426   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2427   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2428   drawTrace.Enable(true);
2429
2430   Actor defaultRootActor = Actor::New(); // Root for default RT
2431   Stage::GetCurrent().Add( defaultRootActor );
2432
2433   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2434   Stage::GetCurrent().Add( offscreenCameraActor );
2435   Actor firstRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2436   Stage::GetCurrent().Add(firstRootActor);
2437
2438   // first render task
2439   RenderTask firstTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, firstRootActor, RenderTask::REFRESH_ONCE, false);
2440   bool firstFinished = false;
2441   RenderTaskFinished renderTask1Finished( firstFinished );
2442   firstTask.FinishedSignal().Connect( &application, renderTask1Finished );
2443
2444   // Second render task
2445   FrameBufferImage fbo = firstTask.GetTargetFrameBuffer();
2446   Actor secondRootActor = CreateRenderableActor( fbo );
2447   Stage::GetCurrent().Add(secondRootActor);
2448   RenderTask secondTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2449   bool secondFinished = false;
2450   RenderTaskFinished renderTask2Finished( secondFinished );
2451   secondTask.FinishedSignal().Connect( &application, renderTask2Finished );
2452
2453   application.SendNotification();
2454
2455   //Both render tasks are executed.
2456   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true, __LINE__ ) );
2457   DALI_TEST_CHECK( firstFinished == false );
2458   DALI_TEST_CHECK( secondFinished == false );
2459
2460   //Nothing else to render and both render task should have finished now
2461   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,  firstFinished, true, false, __LINE__ ) );
2462   DALI_TEST_CHECK( firstFinished == true );
2463   DALI_TEST_CHECK( secondFinished == true );
2464
2465   END_TEST;
2466 }
2467
2468 int UtcDaliRenderTaskProperties(void)
2469 {
2470   TestApplication application;
2471
2472   RenderTask task = Stage::GetCurrent().GetRenderTaskList().CreateTask();
2473
2474   Property::IndexContainer indices;
2475   task.GetPropertyIndices( indices );
2476   DALI_TEST_CHECK( indices.Size() );
2477   DALI_TEST_EQUALS( indices.Size(), task.GetPropertyCount(), TEST_LOCATION );
2478   END_TEST;
2479 }
2480
2481 int UtcDaliRenderTaskFinishInvisibleSourceActor(void)
2482 {
2483   TestApplication application;
2484
2485   tet_infoline("Testing RenderTask::FinishInvisibleSourceActor()");
2486
2487   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2488   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2489
2490   CameraActor offscreenCameraActor = CameraActor::New();
2491
2492   Stage::GetCurrent().Add( offscreenCameraActor );
2493
2494   BufferImage image = BufferImage::New( 10, 10 );
2495   Actor rootActor = CreateRenderableActor( image );
2496   rootActor.SetSize( 10, 10 );
2497   rootActor.SetVisible(false);
2498   Stage::GetCurrent().Add( rootActor );
2499
2500   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2501   NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
2502   FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
2503
2504   // Flush all outstanding messages
2505   application.SendNotification();
2506   application.Render();
2507
2508   RenderTask newTask = taskList.CreateTask();
2509   newTask.SetCameraActor( offscreenCameraActor );
2510   newTask.SetSourceActor( rootActor );
2511   newTask.SetInputEnabled( false );
2512   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
2513   newTask.SetClearEnabled( true );
2514   newTask.SetExclusive( true );
2515   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
2516   newTask.SetTargetFrameBuffer( frameBufferImage );
2517   newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, true );
2518
2519   // Framebuffer doesn't actually get created until Connected, i.e. by previous line
2520
2521   bool finished = false;
2522   RenderTaskFinished renderTaskFinished( finished );
2523   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2524
2525   // Flush the queue and render.
2526   application.SendNotification();
2527
2528   // 1 render to process render task, then wait for sync before finished msg is sent
2529   // from update to the event thread.
2530
2531   application.Render();
2532   application.SendNotification();
2533   DALI_TEST_CHECK( !finished );
2534
2535   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2536   DALI_TEST_CHECK( lastSyncObj != NULL );
2537
2538   application.Render();
2539   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
2540   application.SendNotification();
2541   DALI_TEST_CHECK( !finished );
2542
2543   application.Render();
2544   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
2545   application.SendNotification();
2546   DALI_TEST_CHECK( ! finished );
2547
2548   sync.SetObjectSynced( lastSyncObj, true );
2549
2550   application.Render();
2551   application.SendNotification();
2552   DALI_TEST_CHECK( !finished );
2553
2554   application.Render();
2555   application.SendNotification();
2556   DALI_TEST_CHECK( finished );
2557   finished = false;
2558
2559   application.Render(); // Double check no more finished signal
2560   application.SendNotification();
2561   DALI_TEST_CHECK( ! finished );
2562
2563   END_TEST;
2564 }
2565
2566 int UtcDaliRenderTaskFinishMissingImage(void)
2567 {
2568   TestApplication application;
2569
2570   // Previously we had bugs where not having a resource ID would cause render-tasks to wait forever
2571   tet_infoline("Testing RenderTask::SignalFinished() when an Actor has no Image set");
2572
2573   Stage stage = Stage::GetCurrent();
2574
2575   BufferImage image = BufferImage::New( 10, 10 );
2576   Actor rootActor = CreateRenderableActor( image );
2577   rootActor.SetSize( 10, 10 );
2578   stage.Add( rootActor );
2579
2580   Actor actorWithMissingImage = CreateRenderableActor( Image() );
2581   actorWithMissingImage.SetSize( 10, 10 );
2582   stage.Add( actorWithMissingImage );
2583
2584   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2585   RenderTask newTask = taskList.CreateTask();
2586   newTask.SetInputEnabled( false );
2587   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
2588   newTask.SetClearEnabled( true );
2589   newTask.SetExclusive( true );
2590   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
2591
2592   bool finished = false;
2593   RenderTaskFinished renderTaskFinished( finished );
2594   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2595
2596   // 1 render to process render task, then 1 before finished msg is sent from update to the event thread.
2597   application.SendNotification();
2598   application.Render();
2599   application.Render();
2600
2601   application.SendNotification();
2602   DALI_TEST_CHECK( finished );
2603
2604   END_TEST;
2605 }
2606
2607 int UtcDaliRenderTaskWorldToViewport(void)
2608 {
2609   TestApplication application( 400u, 400u ); // square surface
2610
2611   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2612
2613   Actor actor = Actor::New();
2614   actor.SetSize(100.0f, 100.0f);
2615   actor.SetPosition( Vector3(0.0, 0.0, 0.0) );
2616
2617   actor.SetParentOrigin( Vector3(0.5, 0.5, 0.5) );
2618   actor.SetAnchorPoint( Vector3(0.5, 0.5, 0.5) );
2619
2620   Stage::GetCurrent().Add(actor);
2621
2622   application.SendNotification();
2623   application.Render();
2624   application.SendNotification();
2625
2626   RenderTask task = taskList.GetTask( 0u );
2627
2628   CameraActor camera = task.GetCameraActor();
2629
2630   Vector2 screenSize = task.GetCurrentViewportSize();
2631
2632   float screenX = 0.0;
2633   float screenY = 0.0;
2634
2635   bool ok = task.WorldToViewport(actor.GetCurrentWorldPosition(), screenX, screenY);
2636   DALI_TEST_CHECK(ok == true);
2637
2638   DALI_TEST_EQUALS(screenX, screenSize.x/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2639   DALI_TEST_EQUALS(screenY, screenSize.y/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2640
2641   Actor actor2 = Actor::New();
2642   float actor2Size = 100.f;
2643   actor2.SetSize( actor2Size, actor2Size );
2644   actor2.SetPosition( Vector3(0.0, 0.0, 0.0) );
2645   actor2.SetParentOrigin( Vector3(0.5, 0.5, 0.0) );
2646   actor2.SetAnchorPoint( Vector3(0.5, 0.5, 0.0) );
2647   Stage::GetCurrent().Add( actor2 );
2648   actor2.Add(actor);
2649   actor.SetParentOrigin( Vector3(0,0,0) );
2650
2651   application.SendNotification();
2652   application.Render();
2653   application.SendNotification();
2654
2655   ok = task.WorldToViewport(actor.GetCurrentWorldPosition(), screenX, screenY);
2656   DALI_TEST_CHECK(ok == true);
2657
2658   DALI_TEST_EQUALS(screenX, screenSize.x/2 - actor2Size/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2659   DALI_TEST_EQUALS(screenY, screenSize.y/2 - actor2Size/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2660
2661   END_TEST;
2662 }
2663
2664
2665 int UtcDaliRenderTaskViewportToLocal(void)
2666 {
2667   TestApplication application;
2668   Actor actor = Actor::New();
2669   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
2670   actor.SetSize(100.0f, 100.0f);
2671   actor.SetPosition(10.0f, 10.0f);
2672   Stage::GetCurrent().Add(actor);
2673
2674   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2675   RenderTask task = taskList.GetTask( 0u );
2676
2677   // flush the queue and render once
2678   application.SendNotification();
2679   application.Render();
2680   application.SendNotification();
2681   application.Render();
2682
2683   float localX;
2684   float localY;
2685
2686   float rtLocalX;
2687   float rtLocalY;
2688
2689   float screenX = 50.0f;
2690   float screenY = 50.0f;
2691
2692   DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, screenX, screenY) );
2693
2694   DALI_TEST_CHECK( task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY ) );
2695
2696   DALI_TEST_EQUALS(localX, rtLocalX, 0.01f, TEST_LOCATION);
2697   DALI_TEST_EQUALS(localY, rtLocalY, 0.01f, TEST_LOCATION);
2698
2699   END_TEST;
2700
2701 }
2702
2703 int UtcDaliRenderTaskOffscreenViewportToLocal(void)
2704 {
2705   TestApplication application;
2706   Actor actor = Actor::New();
2707   actor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
2708   actor.SetSize( 100.0f, 100.0f );
2709   actor.SetPosition( 10.0f, 10.0f );
2710   Stage::GetCurrent().Add( actor );
2711
2712   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2713   RenderTask task = taskList.CreateTask();
2714
2715   FrameBufferImage newFrameBuffer = FrameBufferImage::New( 10, 10 );
2716   task.SetTargetFrameBuffer( newFrameBuffer );
2717   task.SetSourceActor( actor );
2718   task.SetScreenToFrameBufferMappingActor( actor );
2719
2720   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2721   Stage::GetCurrent().Add( offscreenCameraActor );
2722   task.SetCameraActor( offscreenCameraActor );
2723
2724   // flush the queue and render once
2725   application.SendNotification();
2726   application.Render();
2727   application.SendNotification();
2728   application.Render();
2729
2730   float localX;
2731   float localY;
2732
2733   float rtLocalX;
2734   float rtLocalY;
2735
2736   float screenX = 50.0f;
2737   float screenY = 50.0f;
2738
2739   DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, screenX, screenY) );
2740
2741   DALI_TEST_CHECK( task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY ) );
2742
2743   DALI_TEST_EQUALS(localX, rtLocalX, 0.01f, TEST_LOCATION);
2744   DALI_TEST_EQUALS(localY, rtLocalY, 0.01f, TEST_LOCATION);
2745
2746   END_TEST;
2747 }
2748
2749 int UtcDaliRenderTaskRequiresSync(void)
2750 {
2751   TestApplication application;
2752   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2753
2754   RenderTask newTask = taskList.CreateTask();
2755   newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, false );
2756
2757   DALI_TEST_EQUALS( newTask.GetProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), false, TEST_LOCATION );
2758   DALI_TEST_EQUALS( newTask.GetCurrentProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), false, TEST_LOCATION );
2759
2760   newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, true );
2761
2762   DALI_TEST_EQUALS( newTask.GetProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), true, TEST_LOCATION );
2763   DALI_TEST_EQUALS( newTask.GetCurrentProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), true, TEST_LOCATION );
2764
2765   END_TEST;
2766 }