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

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <iostream>
  19
  20 #include <stdlib.h>
  21 #include <dali/public-api/dali-core.h>
  22
  23 #include <dali/integration-api/events/touch-event-integ.h>
  24 #include <dali-test-suite-utils.h>
  25
  26 using namespace Dali;
  27
  28 void renderable_actor_startup(void)
  29 {
  30   test_return_value = TET_UNDEF;
  31 }
  32
  33 void renderable_actor_cleanup(void)
  34 {
  35   test_return_value = TET_PASS;
  36 }
  37
  38 namespace
  39 {
  40
  41 static bool gIsActor1SortModifierCorrect;
  42 static bool gIsActor2SortModifierCorrect;
  43 const float gActor1SortModifierValue = 96.0f;
  44 const float gActor2SortModifierValue = 53.0f;
  45
  46 static float TestSortFunction(const Vector3& position, float sortModifier)
  47 {
  48   if ( fabs(sortModifier - gActor1SortModifierValue) < 0.01)
  49     gIsActor1SortModifierCorrect = true;
  50
  51   if ( fabs(sortModifier - gActor2SortModifierValue) < 0.01)
  52     gIsActor2SortModifierCorrect = true;
  53
  54   return 0.0f;
  55 }
  56
  57 } // anon namespace
  58
  59 int UtcDaliRenderableActorDownCast(void)
  60 {
  61   TestApplication application;
  62
  63   tet_infoline("Testing Dali::RenderableActor::DownCast()");
  64
  65   ImageActor imageActor = ImageActor::New();
  66
  67   Actor anActor = Actor::New();
  68   anActor.Add( imageActor );
  69
  70   Actor child = anActor.GetChildAt(0);
  71   RenderableActor renderableActor = RenderableActor::DownCast( child );
  72   DALI_TEST_CHECK( renderableActor );
  73
  74   renderableActor.Reset();
  75   DALI_TEST_CHECK( !renderableActor );
  76
  77   renderableActor = DownCast< RenderableActor >( child );
  78   DALI_TEST_CHECK( renderableActor );
  79
  80   renderableActor = DownCast< RenderableActor >( anActor );
  81   DALI_TEST_CHECK( !renderableActor );
  82
  83   Actor unInitialzedActor;
  84   renderableActor = RenderableActor::DownCast( unInitialzedActor );
  85   DALI_TEST_CHECK( !renderableActor );
  86
  87   renderableActor = DownCast< RenderableActor >( unInitialzedActor );
  88   DALI_TEST_CHECK( !renderableActor );
  89   END_TEST;
  90 }
  91
  92 int UtcDaliRenderableActorSetSortModifier(void)
  93 {
  94   TestApplication application;
  95
  96   tet_infoline("Testing Dali::RenderableActor::SetSortModifier()");
  97
  98   float val = -500.0f;
  99
 100   ImageActor actor = ImageActor::New();
 101   Stage::GetCurrent().Add(actor);
 102
 103   actor.SetSortModifier( val );
 104
 105   float returnValue = actor.GetSortModifier();
 106
 107   //Verify through actor api
 108   DALI_TEST_EQUALS(returnValue, val, TEST_LOCATION);
 109
 110   Stage::GetCurrent().Remove(actor);
 111
 112
 113   //Verify through layer SetSortFunction
 114   gIsActor1SortModifierCorrect = false;
 115   gIsActor2SortModifierCorrect = false;
 116   BufferImage img = BufferImage::New( 1,1 );
 117   // create two transparent actors so there is something to sort
 118   ImageActor actor1 = ImageActor::New( img );
 119   ImageActor actor2 = ImageActor::New( img );
 120   actor1.SetSize(1,1);
 121   actor1.SetPosition( 0, 0, 0);
 122   actor1.SetSortModifier( gActor1SortModifierValue );
 123   actor1.SetColor( Vector4(1, 1, 1, 0.5f ) ); // 50% transparent
 124   actor2.SetSize(1,1);
 125   actor2.SetPosition( 0, 0, 1);
 126   actor2.SetSortModifier( gActor2SortModifierValue );
 127   actor2.SetColor( Vector4(1, 1, 1, 0.5f ) ); // 50% transparent
 128
 129   // add to stage
 130    Stage::GetCurrent().Add( actor1 );
 131    Stage::GetCurrent().Add( actor2 );
 132
 133    Layer root = Stage::GetCurrent().GetLayer( 0 );
 134    root.SetSortFunction( TestSortFunction );
 135
 136    // flush the queue and render once
 137    application.SendNotification();
 138    application.Render();
 139
 140    DALI_TEST_CHECK( gIsActor1SortModifierCorrect && gIsActor2SortModifierCorrect );
 141    END_TEST;
 142
 143 }
 144
 145 int UtcDaliRenderableActorGetSortModifier(void)
 146 {
 147   TestApplication application;
 148
 149   tet_infoline("Testing Dali::RenderableActor::GetSortModifier()");
 150
 151   ImageActor actor = ImageActor::New();
 152   Stage::GetCurrent().Add(actor);
 153
 154   DALI_TEST_EQUALS(actor.GetSortModifier(), 0.0f, TEST_LOCATION);
 155
 156   Stage::GetCurrent().Remove(actor);
 157   END_TEST;
 158 }
 159
 160 int UtcDaliRenderableActorSetGetBlendMode(void)
 161 {
 162   TestApplication application;
 163
 164   tet_infoline("Testing Dali::RenderableActor::SetBlendMode() / Dali::RenderableActor::GetBlendMode()");
 165
 166   ImageActor actor = ImageActor::New();
 167
 168   actor.SetBlendMode( BlendingMode::OFF );
 169   DALI_TEST_CHECK( BlendingMode::OFF == actor.GetBlendMode() );
 170
 171   actor.SetBlendMode( BlendingMode::AUTO );
 172   DALI_TEST_CHECK( BlendingMode::AUTO == actor.GetBlendMode() );
 173
 174   actor.SetBlendMode( BlendingMode::ON );
 175   DALI_TEST_CHECK( BlendingMode::ON == actor.GetBlendMode() );
 176   END_TEST;
 177 }
 178
 179 int UtcDaliRenderableActorSetCullFace(void)
 180 {
 181   TestApplication application;
 182
 183   tet_infoline("Testing Dali::RenderableActor::SetCullFace()");
 184
 185   BufferImage img = BufferImage::New( 1,1 );
 186   ImageActor actor = ImageActor::New( img );
 187   ImageActor actor2 = ImageActor::New( img );
 188
 189   actor.SetSize(100.0f, 100.0f);
 190   actor.SetParentOrigin(ParentOrigin::CENTER);
 191   actor.SetAnchorPoint(AnchorPoint::CENTER);
 192
 193   actor2.SetSize(100.0f, 100.0f);
 194   actor2.SetParentOrigin(ParentOrigin::CENTER);
 195   actor2.SetAnchorPoint(AnchorPoint::CENTER);
 196
 197   Stage::GetCurrent().Add(actor);
 198   Stage::GetCurrent().Add(actor2);
 199
 200   //Verify whether the correct GL calls are made when actor is face culled in front and back, and
 201   // face culling is disabled for actor2
 202   TraceCallStack& cullFaceTrace = application.GetGlAbstraction().GetCullFaceTrace();
 203   cullFaceTrace.Enable(true);
 204   actor.SetCullFace( CullFrontAndBack );
 205
 206   // flush the queue and render once
 207   application.SendNotification();
 208   application.Render();
 209
 210   cullFaceTrace.Enable(false);
 211   std::stringstream out;
 212
 213   //Verify actor gl state
 214   out.str("");
 215   out << GL_BLEND;
 216   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(0, "Enable", out.str()), true, TEST_LOCATION);
 217
 218   out.str("");
 219   out << GL_CULL_FACE;
 220   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(1, "Enable", out.str()), true, TEST_LOCATION);
 221
 222   out.str("");
 223   out << GL_FRONT_AND_BACK;
 224   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(2, "CullFace", out.str()), true, TEST_LOCATION);
 225
 226   //Verify actor2 gl state
 227   out.str("");
 228   out << GL_CULL_FACE;
 229   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(3, "Disable", out.str()), true, TEST_LOCATION);
 230
 231   //Verify state through the actor api
 232   DALI_TEST_CHECK( CullFrontAndBack == actor.GetCullFace() );
 233   DALI_TEST_CHECK( CullNone == actor2.GetCullFace() );
 234
 235   /**************************************************************/
 236
 237   //Verify whether the correct GL calls are made when actor2 is face culled in the front
 238   cullFaceTrace.Reset();
 239   cullFaceTrace.Enable(true);
 240   actor2.SetCullFace( CullFront );
 241
 242   // flush the queue and render once
 243   application.SendNotification();
 244   application.Render();
 245
 246   cullFaceTrace.Enable(false);
 247
 248   //Verify actor gl state
 249   out.str("");
 250   out << GL_CULL_FACE;
 251   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(0, "Enable", out.str()), true, TEST_LOCATION);
 252
 253   out.str("");
 254   out << GL_FRONT_AND_BACK;
 255   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(1, "CullFace", out.str()), true, TEST_LOCATION);
 256
 257   //Verify actor2 gl state
 258   out.str("");
 259   out << GL_CULL_FACE;
 260   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(2, "Enable", out.str()), true, TEST_LOCATION);
 261
 262   out.str("");
 263   out << GL_FRONT;
 264   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(3, "CullFace", out.str()), true, TEST_LOCATION);
 265
 266   //Verify state through the actor api
 267   DALI_TEST_CHECK( CullFrontAndBack == actor.GetCullFace() );
 268   DALI_TEST_CHECK( CullFront == actor2.GetCullFace() );
 269
 270   /**************************************************************/
 271   //Verify whether the correct GL calls are made when face culling is disabled for both actors
 272   cullFaceTrace.Reset();
 273   cullFaceTrace.Enable(true);
 274   actor.SetCullFace( CullNone );
 275   actor2.SetCullFace( CullNone );
 276
 277   // flush the queue and render once
 278   application.SendNotification();
 279   application.Render();
 280
 281   cullFaceTrace.Enable(false);
 282
 283   out.str("");
 284   out << GL_CULL_FACE;
 285   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(0, "Disable", out.str()), true, TEST_LOCATION);
 286
 287   //Verify state through the actor api
 288   DALI_TEST_CHECK( CullNone == actor.GetCullFace() );
 289   DALI_TEST_CHECK( CullNone == actor2.GetCullFace() );
 290
 291   Stage::GetCurrent().Remove(actor);
 292   Stage::GetCurrent().Remove(actor2);
 293   END_TEST;
 294 }
 295
 296 int UtcDaliRenderableActorGetCullFace(void)
 297 {
 298   TestApplication application;
 299
 300   tet_infoline("Testing Dali::RenderableActor::GetCullFace()");
 301
 302   ImageActor imageActor = ImageActor::New();
 303
 304   DALI_TEST_CHECK( CullNone == imageActor.GetCullFace() );
 305
 306   MeshActor meshActor = MeshActor::New();
 307
 308   DALI_TEST_CHECK( CullBack == meshActor.GetCullFace() );
 309   END_TEST;
 310 }
 311
 312 int UtcDaliRenderableActorSetGetBlendFunc(void)
 313 {
 314   TestApplication application;
 315   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 316
 317   tet_infoline("Testing Dali::RenderableActor::UtcDaliRenderableActorSetGetBlendFunc()");
 318
 319   BufferImage img = BufferImage::New( 1,1 );
 320   ImageActor actor = ImageActor::New( img );
 321   Stage::GetCurrent().Add( actor );
 322   application.SendNotification();
 323   application.Render();
 324
 325   // Test the defaults as documented int blending.h
 326   {
 327     BlendingFactor::Type srcFactorRgb( BlendingFactor::ZERO );
 328     BlendingFactor::Type destFactorRgb( BlendingFactor::ZERO );
 329     BlendingFactor::Type srcFactorAlpha( BlendingFactor::ZERO );
 330     BlendingFactor::Type destFactorAlpha( BlendingFactor::ZERO );
 331     actor.GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 332     DALI_TEST_EQUALS( BlendingFactor::SRC_ALPHA,           srcFactorRgb,    TEST_LOCATION );
 333     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_SRC_ALPHA, destFactorRgb,   TEST_LOCATION );
 334     DALI_TEST_EQUALS( BlendingFactor::ONE,                 srcFactorAlpha,  TEST_LOCATION );
 335     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_SRC_ALPHA, destFactorAlpha, TEST_LOCATION );
 336   }
 337
 338   // Set to non-default values
 339   actor.SetBlendFunc( BlendingFactor::ONE_MINUS_SRC_COLOR, BlendingFactor::SRC_ALPHA_SATURATE );
 340
 341   // Test that Set was successful
 342   {
 343     BlendingFactor::Type srcFactorRgb( BlendingFactor::ZERO );
 344     BlendingFactor::Type destFactorRgb( BlendingFactor::ZERO );
 345     BlendingFactor::Type srcFactorAlpha( BlendingFactor::ZERO );
 346     BlendingFactor::Type destFactorAlpha( BlendingFactor::ZERO );
 347     actor.GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 348     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_SRC_COLOR, srcFactorRgb,    TEST_LOCATION );
 349     DALI_TEST_EQUALS( BlendingFactor::SRC_ALPHA_SATURATE,  destFactorRgb,   TEST_LOCATION );
 350     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_SRC_COLOR, srcFactorAlpha,  TEST_LOCATION );
 351     DALI_TEST_EQUALS( BlendingFactor::SRC_ALPHA_SATURATE,  destFactorAlpha, TEST_LOCATION );
 352   }
 353
 354   // Render & check GL commands
 355   application.SendNotification();
 356   application.Render();
 357   DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_SRC_COLOR, glAbstraction.GetLastBlendFuncSrcRgb(),   TEST_LOCATION );
 358   DALI_TEST_EQUALS( (GLenum)GL_SRC_ALPHA_SATURATE,  glAbstraction.GetLastBlendFuncDstRgb(),   TEST_LOCATION );
 359   DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_SRC_COLOR, glAbstraction.GetLastBlendFuncSrcAlpha(), TEST_LOCATION );
 360   DALI_TEST_EQUALS( (GLenum)GL_SRC_ALPHA_SATURATE,  glAbstraction.GetLastBlendFuncDstAlpha(), TEST_LOCATION );
 361
 362   // Set using separate alpha settings
 363   actor.SetBlendFunc( BlendingFactor::CONSTANT_COLOR, BlendingFactor::ONE_MINUS_CONSTANT_COLOR,
 364                       BlendingFactor::CONSTANT_ALPHA, BlendingFactor::ONE_MINUS_CONSTANT_ALPHA );
 365
 366   // Test that Set was successful
 367   {
 368     BlendingFactor::Type srcFactorRgb( BlendingFactor::ZERO );
 369     BlendingFactor::Type destFactorRgb( BlendingFactor::ZERO );
 370     BlendingFactor::Type srcFactorAlpha( BlendingFactor::ZERO );
 371     BlendingFactor::Type destFactorAlpha( BlendingFactor::ZERO );
 372     actor.GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 373     DALI_TEST_EQUALS( BlendingFactor::CONSTANT_COLOR,            srcFactorRgb,    TEST_LOCATION );
 374     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_CONSTANT_COLOR,  destFactorRgb,   TEST_LOCATION );
 375     DALI_TEST_EQUALS( BlendingFactor::CONSTANT_ALPHA,            srcFactorAlpha,  TEST_LOCATION );
 376     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_CONSTANT_ALPHA,  destFactorAlpha, TEST_LOCATION );
 377   }
 378
 379   // Render & check GL commands
 380   application.SendNotification();
 381   application.Render();
 382   DALI_TEST_EQUALS( (GLenum)GL_CONSTANT_COLOR,           glAbstraction.GetLastBlendFuncSrcRgb(),   TEST_LOCATION );
 383   DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_CONSTANT_COLOR, glAbstraction.GetLastBlendFuncDstRgb(),   TEST_LOCATION );
 384   DALI_TEST_EQUALS( (GLenum)GL_CONSTANT_ALPHA,           glAbstraction.GetLastBlendFuncSrcAlpha(), TEST_LOCATION );
 385   DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_CONSTANT_ALPHA, glAbstraction.GetLastBlendFuncDstAlpha(), TEST_LOCATION );
 386   END_TEST;
 387 }
 388
 389 int UtcDaliRenderableActorSetGetBlendEquation(void)
 390 {
 391   TestApplication application;
 392   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 393
 394   tet_infoline("Testing Dali::RenderableActor::SetBlendEquation()");
 395
 396   BufferImage img = BufferImage::New( 1,1 );
 397   ImageActor actor = ImageActor::New( img );
 398   Stage::GetCurrent().Add( actor );
 399   application.SendNotification();
 400   application.Render();
 401
 402   // Test the defaults as documented int blending.h
 403   {
 404     BlendingEquation::Type equationRgb( BlendingEquation::SUBTRACT );
 405     BlendingEquation::Type equationAlpha( BlendingEquation::SUBTRACT );
 406     actor.GetBlendEquation( equationRgb, equationAlpha );
 407     DALI_TEST_EQUALS( BlendingEquation::ADD, equationRgb, TEST_LOCATION );
 408     DALI_TEST_EQUALS( BlendingEquation::ADD, equationAlpha, TEST_LOCATION );
 409   }
 410
 411   // Test the single blending equation setting
 412   {
 413     actor.SetBlendEquation( BlendingEquation::REVERSE_SUBTRACT );
 414     BlendingEquation::Type equationRgba( BlendingEquation::SUBTRACT );
 415     actor.GetBlendEquation( equationRgba, equationRgba );
 416     DALI_TEST_EQUALS( BlendingEquation::REVERSE_SUBTRACT, equationRgba, TEST_LOCATION );
 417   }
 418
 419   actor.SetBlendEquation( BlendingEquation::REVERSE_SUBTRACT, BlendingEquation::REVERSE_SUBTRACT );
 420
 421   // Test that Set was successful
 422   {
 423     BlendingEquation::Type equationRgb( BlendingEquation::SUBTRACT );
 424     BlendingEquation::Type equationAlpha( BlendingEquation::SUBTRACT );
 425     actor.GetBlendEquation( equationRgb, equationAlpha );
 426     DALI_TEST_EQUALS( BlendingEquation::REVERSE_SUBTRACT, equationRgb, TEST_LOCATION );
 427     DALI_TEST_EQUALS( BlendingEquation::REVERSE_SUBTRACT, equationAlpha, TEST_LOCATION );
 428   }
 429
 430   // Render & check GL commands
 431   application.SendNotification();
 432   application.Render();
 433   DALI_TEST_EQUALS( (GLenum)GL_FUNC_REVERSE_SUBTRACT, glAbstraction.GetLastBlendEquationRgb(),   TEST_LOCATION );
 434   DALI_TEST_EQUALS( (GLenum)GL_FUNC_REVERSE_SUBTRACT, glAbstraction.GetLastBlendEquationAlpha(), TEST_LOCATION );
 435   END_TEST;
 436 }
 437
 438 int UtcDaliRenderableActorSetGetBlendColor(void)
 439 {
 440   TestApplication application;
 441   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 442
 443   tet_infoline("Testing Dali::RenderableActor::SetBlendColor()");
 444
 445   BufferImage img = BufferImage::New( 1,1 );
 446   ImageActor actor = ImageActor::New( img );
 447   Stage::GetCurrent().Add( actor );
 448   application.SendNotification();
 449   application.Render();
 450
 451   // Test the defaults as documented int blending.h
 452   DALI_TEST_EQUALS( Vector4::ZERO, actor.GetBlendColor(), TEST_LOCATION );
 453
 454   actor.SetBlendColor( Color::RED );
 455
 456   // Test that Set was successful
 457   DALI_TEST_EQUALS( Color::RED, actor.GetBlendColor(), TEST_LOCATION );
 458
 459   // Render & check GL commands
 460   application.SendNotification();
 461   application.Render();
 462   DALI_TEST_EQUALS( Color::RED, glAbstraction.GetLastBlendColor(),   TEST_LOCATION );
 463   END_TEST;
 464 }
 465
 466 int UtcDaliRenderableActorSetGetAlpha(void)
 467 {
 468   TestApplication application;
 469
 470   tet_infoline("Testing Dali::RenderableActor::SetGetAlpha()");
 471
 472   BufferImage img = BufferImage::New( 1,1 );
 473   ImageActor actor = ImageActor::New( img );
 474   Stage::GetCurrent().Add( actor );
 475   application.SendNotification();
 476   application.Render();
 477
 478   // use the image alpha on actor
 479   actor.SetBlendMode(BlendingMode::ON);
 480
 481   // Test that Set was successful
 482   DALI_TEST_EQUALS( BlendingMode::ON, actor.GetBlendMode(), TEST_LOCATION );
 483
 484   // Now test that it can be set to false
 485   actor.SetBlendMode(BlendingMode::OFF);
 486   DALI_TEST_EQUALS(BlendingMode::OFF, actor.GetBlendMode(), TEST_LOCATION );
 487   END_TEST;
 488 }
 489
 490 int UtcDaliRenderableActorCreateDestroy(void)
 491 {
 492   tet_infoline("Testing Dali::RenderableActor::CreateDestroy()");
 493   RenderableActor* ractor = new RenderableActor;
 494   RenderableActor ractor2( *ractor );
 495   DALI_TEST_CHECK( ractor );
 496   delete ractor;
 497   END_TEST;
 498 }
 499
 500 int UtcDaliRenderableActorSetGetFilterModes(void)
 501 {
 502   TestApplication application;
 503
 504   tet_infoline("Testing Dali::RenderableActor::SetFilterMode() / Dali::RenderableActor::GetFilterMode()");
 505
 506   ImageActor actor = ImageActor::New();
 507
 508   FilterMode::Type minifyFilter = FilterMode::NEAREST;
 509   FilterMode::Type magnifyFilter = FilterMode::NEAREST;
 510
 511   // Default test
 512   actor.GetFilterMode( minifyFilter, magnifyFilter );
 513   DALI_TEST_CHECK( FilterMode::DEFAULT == minifyFilter );
 514   DALI_TEST_CHECK( FilterMode::DEFAULT == magnifyFilter );
 515
 516   // Default/Default
 517   actor.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
 518   actor.GetFilterMode( minifyFilter, magnifyFilter );
 519   DALI_TEST_CHECK( FilterMode::DEFAULT == minifyFilter );
 520   DALI_TEST_CHECK( FilterMode::DEFAULT == magnifyFilter );
 521
 522   // Nearest/Nearest
 523   actor.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
 524   actor.GetFilterMode( minifyFilter, magnifyFilter );
 525   DALI_TEST_CHECK( FilterMode::NEAREST == minifyFilter );
 526   DALI_TEST_CHECK( FilterMode::NEAREST == magnifyFilter );
 527
 528   // Linear/Linear
 529   actor.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR );
 530   actor.GetFilterMode( minifyFilter, magnifyFilter );
 531   DALI_TEST_CHECK( FilterMode::LINEAR == minifyFilter );
 532   DALI_TEST_CHECK( FilterMode::LINEAR == magnifyFilter );
 533
 534   // Nearest/Linear
 535   actor.SetFilterMode( FilterMode::NEAREST, FilterMode::LINEAR );
 536   actor.GetFilterMode( minifyFilter, magnifyFilter );
 537   DALI_TEST_CHECK( FilterMode::NEAREST == minifyFilter );
 538   DALI_TEST_CHECK( FilterMode::LINEAR == magnifyFilter );
 539
 540   // Linear/Nearest
 541   actor.SetFilterMode( FilterMode::LINEAR, FilterMode::NEAREST );
 542   actor.GetFilterMode( minifyFilter, magnifyFilter );
 543   DALI_TEST_CHECK( FilterMode::LINEAR == minifyFilter );
 544   DALI_TEST_CHECK( FilterMode::NEAREST == magnifyFilter );
 545
 546   END_TEST;
 547 }
 548
 549 int UtcDaliRenderableActorSetFilterMode(void)
 550 {
 551   TestApplication application;
 552
 553   tet_infoline("Testing Dali::RenderableActor::SetFilterMode()");
 554
 555   BufferImage img = BufferImage::New( 1,1 );
 556   ImageActor actor = ImageActor::New( img );
 557
 558   actor.SetSize(100.0f, 100.0f);
 559   actor.SetParentOrigin(ParentOrigin::CENTER);
 560   actor.SetAnchorPoint(AnchorPoint::CENTER);
 561
 562   Stage::GetCurrent().Add(actor);
 563
 564   /**************************************************************/
 565
 566   // Default/Default
 567   TraceCallStack& texParameterTrace = application.GetGlAbstraction().GetTexParameterTrace();
 568   texParameterTrace.Reset();
 569   texParameterTrace.Enable( true );
 570
 571   actor.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
 572
 573   // Flush the queue and render once
 574   application.SendNotification();
 575   application.Render();
 576
 577   texParameterTrace.Enable( false );
 578
 579   std::stringstream out;
 580
 581   // Verify actor gl state
 582
 583   // There are two calls to TexParameteri when the texture is first created
 584   // Texture mag filter is not called as the first time set it uses the system default
 585   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 3, TEST_LOCATION);
 586
 587   out.str("");
 588   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_LINEAR;
 589   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(2, "TexParameteri", out.str()), true, TEST_LOCATION);
 590
 591   /**************************************************************/
 592
 593   // Default/Default
 594   texParameterTrace = application.GetGlAbstraction().GetTexParameterTrace();
 595   texParameterTrace.Reset();
 596   texParameterTrace.Enable( true );
 597
 598   actor.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
 599
 600   // Flush the queue and render once
 601   application.SendNotification();
 602   application.Render();
 603
 604   texParameterTrace.Enable( false );
 605
 606   // Verify actor gl state
 607
 608   // Should not make any calls when settings are the same
 609   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 0, TEST_LOCATION);
 610
 611   /**************************************************************/
 612
 613   // Nearest/Nearest
 614   texParameterTrace.Reset();
 615   texParameterTrace.Enable( true );
 616
 617   actor.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
 618
 619   // Flush the queue and render once
 620   application.SendNotification();
 621   application.Render();
 622
 623   texParameterTrace.Enable( false );
 624
 625   // Verify actor gl state
 626   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 2, TEST_LOCATION);
 627
 628   out.str("");
 629   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_NEAREST;
 630   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
 631
 632   out.str("");
 633   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MAG_FILTER << ", " << GL_NEAREST;
 634   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(1, "TexParameteri", out.str()), true, TEST_LOCATION);
 635
 636   /**************************************************************/
 637
 638   // Linear/Linear
 639   texParameterTrace.Reset();
 640   texParameterTrace.Enable( true );
 641
 642   actor.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR );
 643
 644   // Flush the queue and render once
 645   application.SendNotification();
 646   application.Render();
 647
 648   texParameterTrace.Enable( false );
 649
 650   // Verify actor gl state
 651   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 2, TEST_LOCATION);
 652
 653   out.str("");
 654   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_LINEAR;
 655   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
 656
 657   out.str("");
 658   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MAG_FILTER << ", " << GL_LINEAR;
 659   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(1, "TexParameteri", out.str()), true, TEST_LOCATION);
 660
 661
 662   /**************************************************************/
 663
 664   // Nearest/Linear
 665   texParameterTrace.Reset();
 666   texParameterTrace.Enable( true );
 667
 668   actor.SetFilterMode( FilterMode::NEAREST, FilterMode::LINEAR );
 669
 670   // Flush the queue and render once
 671   application.SendNotification();
 672   application.Render();
 673
 674   texParameterTrace.Enable( false );
 675
 676   // Verify actor gl state
 677   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 1, TEST_LOCATION);
 678
 679   out.str("");
 680   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_NEAREST;
 681   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
 682
 683   /**************************************************************/
 684
 685   // Default/Default
 686   texParameterTrace.Reset();
 687   texParameterTrace.Enable( true );
 688
 689   actor.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
 690
 691   // Flush the queue and render once
 692   application.SendNotification();
 693   application.Render();
 694
 695   texParameterTrace.Enable( false );
 696
 697   // Verify actor gl state
 698   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 1, TEST_LOCATION);
 699
 700   out.str("");
 701   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_LINEAR;
 702   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
 703
 704   /**************************************************************/
 705
 706   // None/None
 707   texParameterTrace.Reset();
 708   texParameterTrace.Enable( true );
 709
 710   actor.SetFilterMode( FilterMode::NONE, FilterMode::NONE );
 711
 712   // Flush the queue and render once
 713   application.SendNotification();
 714   application.Render();
 715
 716   texParameterTrace.Enable( false );
 717
 718   // Verify actor gl state
 719   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 1, TEST_LOCATION);
 720
 721   out.str("");
 722   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_NEAREST_MIPMAP_LINEAR;
 723   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
 724
 725   /**************************************************************/
 726
 727   Stage::GetCurrent().Remove(actor);
 728
 729   END_TEST;
 730 }
 731
 732 int UtcDaliRenderableActorSetShaderEffect(void)
 733 {
 734   TestApplication application;
 735   BufferImage img = BufferImage::New( 1,1 );
 736   ImageActor actor = ImageActor::New( img );
 737   Stage::GetCurrent().Add( actor );
 738
 739   // flush the queue and render once
 740   application.SendNotification();
 741   application.Render();
 742   GLuint lastShaderCompiledBefore = application.GetGlAbstraction().GetLastShaderCompiled();
 743
 744   application.GetGlAbstraction().EnableShaderCallTrace( true );
 745
 746   const std::string vertexShader = "UtcDaliRenderableActorSetShaderEffect-VertexSource";
 747   const std::string fragmentShader = "UtcDaliRenderableActorSetShaderEffect-FragmentSource";
 748   ShaderEffect effect = ShaderEffect::New(vertexShader, fragmentShader );
 749   DALI_TEST_CHECK( effect != actor.GetShaderEffect() );
 750
 751   actor.SetShaderEffect( effect );
 752   DALI_TEST_CHECK( effect == actor.GetShaderEffect() );
 753
 754   // flush the queue and render once
 755   application.SendNotification();
 756   application.Render();
 757
 758   GLuint lastShaderCompiledAfter = application.GetGlAbstraction().GetLastShaderCompiled();
 759   DALI_TEST_EQUALS( lastShaderCompiledAfter, lastShaderCompiledBefore + 2, TEST_LOCATION );
 760
 761   std::string actualVertexShader = application.GetGlAbstraction().GetShaderSource( lastShaderCompiledBefore + 1 );
 762   DALI_TEST_EQUALS( vertexShader,
 763                     actualVertexShader.substr( actualVertexShader.length() - vertexShader.length() ), TEST_LOCATION );
 764   std::string actualFragmentShader = application.GetGlAbstraction().GetShaderSource( lastShaderCompiledBefore + 2 );
 765   DALI_TEST_EQUALS( fragmentShader,
 766                     actualFragmentShader.substr( actualFragmentShader.length() - fragmentShader.length() ), TEST_LOCATION );
 767
 768   END_TEST;
 769 }
 770
 771 int UtcDaliRenderableActorGetShaderEffect(void)
 772 {
 773   TestApplication application;
 774   ImageActor actor = ImageActor::New();
 775
 776   ShaderEffect effect = ShaderEffect::New("UtcDaliRenderableActorGetShaderEffect-VertexSource", "UtcDaliRenderableActorGetShaderEffect-FragmentSource" );
 777   actor.SetShaderEffect(effect);
 778
 779   DALI_TEST_CHECK(effect == actor.GetShaderEffect());
 780   END_TEST;
 781 }
 782
 783 int UtcDaliRenderableActorRemoveShaderEffect01(void)
 784 {
 785   TestApplication application;
 786   ImageActor actor = ImageActor::New();
 787
 788   ShaderEffect defaultEffect = actor.GetShaderEffect();
 789
 790   ShaderEffect effect = ShaderEffect::New("UtcDaliRenderableActorRemoveShaderEffect-VertexSource", "UtcDaliRenderableActorRemoveShaderEffect-FragmentSource" );
 791   actor.SetShaderEffect(effect);
 792
 793   DALI_TEST_CHECK(effect == actor.GetShaderEffect());
 794
 795   actor.RemoveShaderEffect();
 796
 797   DALI_TEST_CHECK(defaultEffect == actor.GetShaderEffect());
 798   END_TEST;
 799 }
 800
 801 int UtcDaliRenderableActorRemoveShaderEffect02(void)
 802 {
 803   TestApplication application;
 804   ImageActor actor = ImageActor::New();
 805
 806   ShaderEffect defaultEffect = actor.GetShaderEffect();
 807
 808   actor.RemoveShaderEffect();
 809
 810   DALI_TEST_CHECK(defaultEffect == actor.GetShaderEffect());
 811   END_TEST;
 812 }
 813
 814 int UtcDaliSetShaderEffectRecursively(void)
 815 {
 816   TestApplication application;
 817   /**
 818    * create a tree
 819    *                 actor1
 820    *           actor2       actor4
 821    *       actor3 imageactor1
 822    * imageactor2
 823    */
 824   BufferImage img = BufferImage::New( 1,1 );
 825   ImageActor actor1 = ImageActor::New( img );
 826   Actor actor2 = Actor::New();
 827   actor1.Add( actor2 );
 828   Actor actor3 = Actor::New();
 829   actor2.Add( actor3 );
 830   ImageActor imageactor1 = ImageActor::New( img );
 831   actor2.Add( imageactor1 );
 832   ImageActor imageactor2 = ImageActor::New( img );
 833   actor3.Add( imageactor2 );
 834   Actor actor4 = Actor::New();
 835   actor1.Add( actor4 );
 836   Stage::GetCurrent().Add( actor1 );
 837
 838   // flush the queue and render once
 839   application.SendNotification();
 840   application.Render();
 841   GLuint lastShaderCompiledBefore = application.GetGlAbstraction().GetLastShaderCompiled();
 842
 843   application.GetGlAbstraction().EnableShaderCallTrace( true );
 844
 845   const std::string vertexShader = "UtcDaliRenderableActorSetShaderEffect-VertexSource";
 846   const std::string fragmentShader = "UtcDaliRenderableActorSetShaderEffect-FragmentSource";
 847   // test with empty effect
 848   ShaderEffect effect;
 849   SetShaderEffectRecursively( actor1, effect );
 850
 851   effect = ShaderEffect::New(vertexShader, fragmentShader );
 852
 853   DALI_TEST_CHECK( effect != actor1.GetShaderEffect() );
 854   DALI_TEST_CHECK( effect != imageactor1.GetShaderEffect() );
 855   DALI_TEST_CHECK( effect != imageactor2.GetShaderEffect() );
 856
 857   SetShaderEffectRecursively( actor1, effect );
 858   DALI_TEST_CHECK( effect == imageactor1.GetShaderEffect() );
 859   DALI_TEST_CHECK( effect == imageactor2.GetShaderEffect() );
 860
 861   // flush the queue and render once
 862   application.SendNotification();
 863   application.Render();
 864
 865   GLuint lastShaderCompiledAfter = application.GetGlAbstraction().GetLastShaderCompiled();
 866   DALI_TEST_EQUALS( lastShaderCompiledAfter, lastShaderCompiledBefore + 2, TEST_LOCATION );
 867
 868   std::string actualVertexShader = application.GetGlAbstraction().GetShaderSource( lastShaderCompiledBefore + 1 );
 869   DALI_TEST_EQUALS( vertexShader,
 870                     actualVertexShader.substr( actualVertexShader.length() - vertexShader.length() ), TEST_LOCATION );
 871   std::string actualFragmentShader = application.GetGlAbstraction().GetShaderSource( lastShaderCompiledBefore + 2 );
 872   DALI_TEST_EQUALS( fragmentShader,
 873                     actualFragmentShader.substr( actualFragmentShader.length() - fragmentShader.length() ), TEST_LOCATION );
 874
 875   // remove from one that does not have shader
 876   RemoveShaderEffectRecursively( actor4 );
 877
 878   // remove partially
 879   RemoveShaderEffectRecursively( actor3 );
 880   DALI_TEST_CHECK( effect == imageactor1.GetShaderEffect() );
 881   DALI_TEST_CHECK( effect != imageactor2.GetShaderEffect() );
 882
 883   // test with empty actor just to check it does not crash
 884   Actor empty;
 885   SetShaderEffectRecursively( empty, effect );
 886   RemoveShaderEffectRecursively( empty );
 887
 888   // test with actor with no children just to check it does not crash
 889   Actor loner = Actor::New();
 890   Stage::GetCurrent().Add( loner );
 891   SetShaderEffectRecursively( loner, effect );
 892   RemoveShaderEffectRecursively( loner );
 893
 894   END_TEST;
 895 }
 896
 897 int UtcDaliRenderableActorTestClearCache01(void)
 898 {
 899   // Testing the framebuffer state caching in frame-buffer-state-caching.cpp
 900   TestApplication application;
 901
 902   tet_infoline("Testing Dali::RenderableActor::ClearCache01()");
 903
 904   BufferImage img = BufferImage::New( 1,1 );
 905   ImageActor actor = ImageActor::New( img );
 906
 907   actor.SetParentOrigin(ParentOrigin::CENTER);
 908   actor.SetAnchorPoint(AnchorPoint::CENTER);
 909
 910   Stage::GetCurrent().Add(actor);
 911
 912   /**************************************************************/
 913   // Flush the queue and render once
 914   application.SendNotification();
 915   application.Render();
 916
 917   // There should be a single call to Clear
 918   DALI_TEST_EQUALS( application.GetGlAbstraction().GetClearCountCalled() , 1u, TEST_LOCATION );
 919
 920   // the last set clear mask should be COLOR, DEPTH & STENCIL which occurs at the start of each frame
 921   GLbitfield mask = application.GetGlAbstraction().GetLastClearMask();
 922   DALI_TEST_CHECK( mask & GL_DEPTH_BUFFER_BIT );
 923   DALI_TEST_CHECK( mask & GL_STENCIL_BUFFER_BIT );
 924   DALI_TEST_CHECK( mask & GL_COLOR_BUFFER_BIT );
 925
 926   END_TEST;
 927 }
 928
 929 int UtcDaliRenderableActorTestClearCache02(void)
 930 {
 931   // Testing the framebuffer state caching in frame-buffer-state-caching.cpp
 932   TestApplication application;
 933
 934   tet_infoline("Testing Dali::RenderableActor::ClearCache02()");
 935
 936   // use RGB so alpha is disabled and the actors are drawn opaque
 937   BufferImage img = BufferImage::New( 10,10 ,Pixel::RGB888 );
 938
 939   // Without caching DALi perform clears in the following places
 940   // Root
 941   // | glClear #1 ( everything at start of frame )
 942   // |
 943   // |
 944   // | glClear #2 ( start of layer with opaque actors )
 945   // | ----> Layer1
 946   // |     -> Actor 1 ( opaque )
 947   // |     -> Actor 2 ( opaque )
 948   // |
 949   // |
 950   // | glClear  #3 ( start of layer with opaque actors )
 951   // |----> Layer 2
 952   // |     -> Actor 3 ( opaque )
 953   // |     -> Actor 4 ( opaque )
 954   //
 955   // With caching enabled glClear should only be called twice, at points #1 and #3.
 956   // At #1 with depth, color and stencil cleared
 957   // At #3 with depth cleared
 958   // #2 is not required because the buffer has already been cleared at #1
 959
 960   Layer layer1 = Layer::New();
 961   layer1.Add( ImageActor::New( img ) );
 962   layer1.Add( ImageActor::New( img ) );
 963
 964   Layer layer2 = Layer::New();
 965   layer2.Add( ImageActor::New( img ) );
 966   layer2.Add( ImageActor::New( img ) );
 967
 968   Stage::GetCurrent().Add( layer1 );
 969   Stage::GetCurrent().Add( layer2 );
 970
 971   /**************************************************************/
 972
 973   // Flush the queue and render once
 974   application.SendNotification();
 975   application.Render();
 976
 977   // There should be a 2 calls to Clear
 978   DALI_TEST_EQUALS( application.GetGlAbstraction().GetClearCountCalled() , 2u, TEST_LOCATION );
 979
 980   // the last set clear mask should be  DEPTH & STENCIL & COLOR
 981   GLbitfield mask = application.GetGlAbstraction().GetLastClearMask();
 982
 983   tet_printf(" clear count = %d \n",  application.GetGlAbstraction().GetClearCountCalled() );
 984
 985   // The last clear should just be DEPTH BUFFER, not color and stencil which were cleared at the start of the frame
 986   DALI_TEST_CHECK( mask & GL_DEPTH_BUFFER_BIT );
 987   DALI_TEST_CHECK( ! ( mask & GL_COLOR_BUFFER_BIT ) );
 988   DALI_TEST_CHECK( ! ( mask & GL_STENCIL_BUFFER_BIT ) );
 989
 990   END_TEST;
 991 }
 992
 993 int UtcDaliRenderableActorTestClearCache03(void)
 994 {
 995   // Testing the framebuffer state caching in frame-buffer-state-caching.cpp
 996   TestApplication application;
 997
 998   tet_infoline("Testing Dali::RenderableActor::ClearCache03()");
 999
1000   // use RGB so alpha is disabled and the actors are drawn opaque
1001   BufferImage img = BufferImage::New( 10,10 ,Pixel::RGB888 );
1002
1003   // Without caching DALi perform clears in the following places
1004   // Root
1005   // | 1-## glClear ( COLOR, DEPTH, STENCIL )
1006   // |
1007   // | ----> Layer1
1008   // |     2-##  glClear  ( STENCIL )
1009   // |     -> Actor 1 ( stencil )
1010   // |     3-##  glClear  ( DEPTH )
1011   // |     -> Actor 2 ( opaque )  // need 2 opaque actors to bypass optimisation of turning off depth test
1012   // |     -> Actor 3 ( opaque )
1013   // |
1014   // |
1015   // |----> Layer 2
1016   // |     4-##  glClear  ( STENCIL )
1017   // |     -> Actor 4 ( stencil )
1018   // |     5-##  glClear  ( DEPTH )
1019   // |     -> Actor 5 ( opaque )  // need 2 opaque actors to bypass optimisation of turning off depth test
1020   // |     -> Actor 6 ( opaque )
1021   //
1022   // With caching enabled glClear will not be called at ## 2 and ## 3 ( because those buffers are already clear).
1023   //
1024   // @TODO Add further optimisation to look-ahead in the render-list to see if
1025   // When performing STENCIL clear, check if there another layer after it.
1026   // If there is, combine the STENCIL with a DEPTH clear.
1027   //
1028
1029   Layer layer1 = Layer::New();
1030   ImageActor actor1 =  ImageActor::New( img );
1031   ImageActor actor2 =  ImageActor::New( img );
1032   ImageActor actor3 =  ImageActor::New( img );
1033
1034   actor2.SetDrawMode( DrawMode::STENCIL );
1035
1036   layer1.Add( actor1 );
1037   layer1.Add( actor2 );
1038   layer1.Add( actor3 );
1039
1040   Layer layer2 = Layer::New();
1041   ImageActor actor4 =  ImageActor::New( img );
1042   ImageActor actor5 =  ImageActor::New( img );
1043   ImageActor actor6 =  ImageActor::New( img );
1044
1045   actor4.SetDrawMode( DrawMode::STENCIL );
1046
1047   layer2.Add( actor4 );
1048   layer2.Add( actor5 );
1049   layer2.Add( actor6 );
1050
1051   Stage::GetCurrent().Add( layer1 );
1052   Stage::GetCurrent().Add( layer2 );
1053
1054
1055   /**************************************************************/
1056
1057   // Flush the queue and render once
1058   application.SendNotification();
1059   application.Render();
1060
1061   // There should be a 3 calls to Clear ( one for everything, one for stencil, one for depth buffer).
1062   DALI_TEST_EQUALS( application.GetGlAbstraction().GetClearCountCalled() , 3u, TEST_LOCATION );
1063
1064   // the last set clear mask should be  DEPTH & STENCIL & COLOR
1065   GLbitfield mask = application.GetGlAbstraction().GetLastClearMask();
1066
1067   tet_printf(" clear count = %d \n",  application.GetGlAbstraction().GetClearCountCalled() );
1068   tet_printf(" clear mask  = %x \n",  mask);
1069
1070   // The last clear should just be DEPTH BUFFER and stencil
1071   DALI_TEST_CHECK(  !( mask & GL_COLOR_BUFFER_BIT ) );
1072   DALI_TEST_CHECK(  !( mask & GL_STENCIL_BUFFER_BIT ) );
1073   DALI_TEST_CHECK(  mask & GL_DEPTH_BUFFER_BIT );
1074
1075
1076   END_TEST;
1077 }