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