automated-tests/src/dali-toolkit/utc-Dali-RendererFactory.cpp

   1 /*
   2  * Copyright (c) 2015 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 #include <iostream>
  18 #include <stdlib.h>
  19 #include <dali-toolkit-test-suite-utils.h>
  20 #include <toolkit-event-thread-callback.h>
  21 #include <dali/devel-api/rendering/renderer.h>
  22 #include <dali/devel-api/rendering/texture-set.h>
  23 #include <dali/devel-api/rendering/shader.h>
  24 #include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
  25
  26 using namespace Dali;
  27 using namespace Dali::Toolkit;
  28
  29 namespace
  30 {
  31 typedef NinePatchImage::StretchRanges StretchRanges;
  32
  33 const char* TEST_IMAGE_FILE_NAME =  "gallery_image_01.jpg";
  34 const char* TEST_NPATCH_FILE_NAME =  "gallery_image_01.9.jpg";
  35
  36 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
  37
  38 Integration::Bitmap* CreateBitmap( unsigned int imageWidth, unsigned int imageHeight, unsigned int initialColor, Pixel::Format pixelFormat )
  39 {
  40   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
  41   Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
  42   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  43
  44   memset( pixbuffer, initialColor, imageHeight * imageWidth * bytesPerPixel );
  45
  46   return bitmap;
  47 }
  48
  49 void InitialiseRegionsToZeroAlpha( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
  50 {
  51   PixelBuffer* pixbuffer = image->GetBuffer();
  52   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  53
  54   for( unsigned int row = 0; row < imageWidth; ++row )
  55   {
  56     unsigned int pixelOffset = row * bytesPerPixel;
  57     pixbuffer[ pixelOffset + 3 ] = 0x00;
  58     pixelOffset += ( imageHeight - 1 ) * imageWidth * bytesPerPixel;
  59     pixbuffer[ pixelOffset + 3 ] = 0x00;
  60   }
  61
  62   for ( unsigned int column = 0; column < imageHeight; ++column )
  63   {
  64     unsigned int pixelOffset = column * imageWidth * bytesPerPixel;
  65     pixbuffer[ pixelOffset + 3 ] = 0x00;
  66     pixelOffset += ( imageWidth -1 ) * bytesPerPixel;
  67     pixbuffer[ pixelOffset + 3 ] = 0x00;
  68   }
  69 }
  70
  71 void AddStretchRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const StretchRanges& stretchRangesX, const StretchRanges& stretchRangesY, Pixel::Format pixelFormat )
  72 {
  73   PixelBuffer* pixbuffer = image->GetBuffer();
  74   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  75
  76   for(StretchRanges::ConstIterator it = stretchRangesX.Begin(); it != stretchRangesX.End(); ++it)
  77   {
  78     const Uint16Pair& range = *it;
  79     //since the stretch range is in the cropped image space, we need to offset by 1 to get it to the uncropped image space
  80     for( unsigned int column = range.GetX() + 1u; column < range.GetY() + 1u; ++column )
  81     {
  82       unsigned int pixelOffset = column * bytesPerPixel;
  83       pixbuffer[ pixelOffset ] = 0x00;
  84       pixbuffer[ pixelOffset + 1 ] = 0x00;
  85       pixbuffer[ pixelOffset + 2 ] = 0x00;
  86       pixbuffer[ pixelOffset + 3 ] = 0xFF;
  87     }
  88   }
  89
  90
  91   for(StretchRanges::ConstIterator it = stretchRangesY.Begin(); it != stretchRangesY.End(); ++it)
  92   {
  93     const Uint16Pair& range = *it;
  94     //since the stretch range is in the cropped image space, we need to offset by 1 to get it to the uncropped image space
  95     for( unsigned int row = range.GetX() + 1u; row < range.GetY() + 1u; ++row )
  96     {
  97       unsigned int pixelOffset = row * imageWidth * bytesPerPixel;
  98       pixbuffer[ pixelOffset ] = 0x00;
  99       pixbuffer[ pixelOffset + 1 ] = 0x00;
 100       pixbuffer[ pixelOffset + 2 ] = 0x00;
 101       pixbuffer[ pixelOffset + 3 ] = 0xFF;
 102     }
 103   }
 104 }
 105
 106 void AddChildRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const Vector4& requiredChildRegion, Pixel::Format pixelFormat )
 107 {
 108   PixelBuffer* pixbuffer = image->GetBuffer();
 109   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
 110
 111   Integration::Bitmap::PackedPixelsProfile* srcProfile = image->GetPackedPixelsProfile();
 112   unsigned int bufferStride = srcProfile->GetBufferStride();
 113
 114   // Add bottom child region
 115   for( unsigned int column = requiredChildRegion.x; column < imageWidth - requiredChildRegion.z; ++column )
 116   {
 117     unsigned int pixelOffset = column * bytesPerPixel;
 118     pixelOffset += ( imageHeight - 1 ) * bufferStride;
 119     pixbuffer[ pixelOffset ] = 0x00;
 120     pixbuffer[ pixelOffset + 1 ] = 0x00;
 121     pixbuffer[ pixelOffset + 2 ] = 0x00;
 122     pixbuffer[ pixelOffset + 3 ] = 0xFF;
 123   }
 124
 125   // Add right child region
 126   for ( unsigned int row = requiredChildRegion.y; row < imageHeight - requiredChildRegion.w; ++row )
 127   {
 128     unsigned int pixelOffset = row * bufferStride + ( imageWidth - 1 ) * bytesPerPixel;
 129     pixbuffer[ pixelOffset ] = 0x00;
 130     pixbuffer[ pixelOffset + 1 ] = 0x00;
 131     pixbuffer[ pixelOffset + 2 ] = 0x00;
 132     pixbuffer[ pixelOffset + 3 ] = 0xFF;
 133   }
 134 }
 135
 136 Integration::ResourcePointer CustomizeNinePatch( TestApplication& application,
 137                                                  unsigned int ninePatchImageWidth,
 138                                                  unsigned int ninePatchImageHeight,
 139                                                  const StretchRanges& stretchRangesX,
 140                                                  const StretchRanges& stretchRangesY,
 141                                                  bool addChildRegion = false,
 142                                                  Vector4 requiredChildRegion = Vector4::ZERO )
 143 {
 144   TestPlatformAbstraction& platform = application.GetPlatform();
 145
 146   Pixel::Format pixelFormat = Pixel::RGBA8888;
 147
 148   tet_infoline("Create Bitmap");
 149   platform.SetClosestImageSize(Vector2( ninePatchImageWidth, ninePatchImageHeight));
 150   Integration::Bitmap* bitmap = CreateBitmap( ninePatchImageWidth, ninePatchImageHeight, 0xFF, pixelFormat );
 151
 152   tet_infoline("Clear border regions");
 153   InitialiseRegionsToZeroAlpha( bitmap, ninePatchImageWidth, ninePatchImageHeight, pixelFormat );
 154
 155   tet_infoline("Add Stretch regions to Bitmap");
 156   AddStretchRegionsToImage( bitmap, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY, pixelFormat );
 157
 158   if( addChildRegion )
 159   {
 160     tet_infoline("Add Child regions to Bitmap");
 161     AddChildRegionsToImage( bitmap, ninePatchImageWidth, ninePatchImageHeight, requiredChildRegion, pixelFormat );
 162   }
 163
 164   tet_infoline("Getting resource");
 165   Integration::ResourcePointer resourcePtr(bitmap);
 166   platform.SetResourceLoaded( 0, Dali::Integration::ResourceBitmap, resourcePtr );
 167
 168   return resourcePtr;
 169 }
 170
 171 void TestControlRendererRender( ToolkitTestApplication& application,
 172                                 Actor& actor,
 173                                 ControlRenderer& controlRenderer,
 174                                 std::size_t expectedSamplers = 0,
 175                                 ImageDimensions imageDimensions = ImageDimensions(),
 176                                 Integration::ResourcePointer resourcePtr = Integration::ResourcePointer())
 177 {
 178   if( resourcePtr )
 179   {
 180     // set the image size, for test case, this needs to be set before loading started
 181     application.GetPlatform().SetClosestImageSize(  Vector2(imageDimensions.GetWidth(), imageDimensions.GetHeight()) );
 182   }
 183
 184   actor.SetSize( 200.f, 200.f );
 185   Stage::GetCurrent().Add( actor );
 186   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 187   controlRenderer.SetOnStage( actor );
 188
 189   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 190
 191   application.SendNotification();
 192   application.Render();
 193
 194   if( resourcePtr )
 195   {
 196     Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
 197     if(request)
 198     {
 199       application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, resourcePtr );
 200     }
 201   }
 202
 203   application.Render();
 204   application.SendNotification();
 205
 206   if( resourcePtr )
 207   {
 208     DALI_TEST_CHECK(application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc));
 209   }
 210
 211   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 212
 213 }
 214
 215 } // namespace
 216
 217
 218 void dali_renderer_factory_startup(void)
 219 {
 220   test_return_value = TET_UNDEF;
 221 }
 222
 223 void dali_renderer_factory_cleanup(void)
 224 {
 225   test_return_value = TET_PASS;
 226 }
 227
 228 int UtcDaliRendererFactoryGet(void)
 229 {
 230   ToolkitTestApplication application;
 231   tet_infoline( "UtcDaliRendererFactory" );
 232
 233   //Register type
 234   TypeInfo type;
 235   type = TypeRegistry::Get().GetTypeInfo( "RendererFactory" );
 236   DALI_TEST_CHECK( type );
 237   BaseHandle handle = type.CreateInstance();
 238   DALI_TEST_CHECK( handle );
 239
 240   RendererFactory factory;
 241   factory = RendererFactory::Get();
 242   DALI_TEST_CHECK( factory );
 243
 244   RendererFactory newFactory = RendererFactory::Get();
 245   DALI_TEST_CHECK( newFactory );
 246
 247   // Check that renderer factory is a singleton
 248   DALI_TEST_CHECK(factory == newFactory);
 249
 250   END_TEST;
 251 }
 252
 253 int UtcDaliRendererFactoryCopyAndAssignment(void)
 254 {
 255   ToolkitTestApplication application;
 256   tet_infoline( "UtcDaliRendererFactoryCopyAndAssignment" );
 257   RendererFactory factory = RendererFactory::Get();
 258
 259   RendererFactory factoryCopy( factory );
 260   DALI_TEST_CHECK(factory == factoryCopy);
 261
 262   RendererFactory emptyFactory;
 263   RendererFactory emptyFactoryCopy( emptyFactory );
 264   DALI_TEST_CHECK(emptyFactory == emptyFactoryCopy);
 265
 266   RendererFactory factoryEquals;
 267   factoryEquals = factory;
 268   DALI_TEST_CHECK(factory == factoryEquals);
 269
 270   RendererFactory emptyFactoryEquals;
 271   emptyFactoryEquals = emptyFactory;
 272   DALI_TEST_CHECK( emptyFactory == emptyFactoryEquals );
 273
 274   //self assignment
 275   factory = factory;
 276   DALI_TEST_CHECK( factory = factoryCopy );
 277
 278   END_TEST;
 279 }
 280
 281 int UtcDaliRendererFactoryGetColorRenderer1(void)
 282 {
 283   ToolkitTestApplication application;
 284   tet_infoline( "UtcDaliRendererFactoryGetColorRenderer1:  Request color renderer with a Property::Map" );
 285
 286   RendererFactory factory = RendererFactory::Get();
 287   DALI_TEST_CHECK( factory );
 288
 289   Property::Map propertyMap;
 290   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 291   propertyMap.Insert("rendererType",  "color");
 292   propertyMap.Insert("blendColor",  testColor);
 293
 294   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 295   DALI_TEST_CHECK( controlRenderer );
 296
 297   Actor actor = Actor::New();
 298   TestControlRendererRender( application, actor, controlRenderer );
 299
 300   Vector4 actualValue(Vector4::ZERO);
 301   TestGlAbstraction& gl = application.GetGlAbstraction();
 302   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "blendColor", actualValue ) );
 303   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 304
 305   END_TEST;
 306 }
 307
 308 int UtcDaliRendererFactoryGetColorRenderer2(void)
 309 {
 310   ToolkitTestApplication application;
 311   tet_infoline( "UtcDaliRendererFactoryGetColorRenderer2: Request color renderer with a Vector4" );
 312
 313   RendererFactory factory = RendererFactory::Get();
 314   DALI_TEST_CHECK( factory );
 315
 316   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 317   ControlRenderer controlRenderer = factory.GetControlRenderer(testColor);
 318   DALI_TEST_CHECK( controlRenderer );
 319
 320   Actor actor = Actor::New();
 321   TestControlRendererRender( application, actor, controlRenderer );
 322
 323   Vector4 actualValue(Vector4::ZERO);
 324   TestGlAbstraction& gl = application.GetGlAbstraction();
 325   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "blendColor", actualValue ) );
 326   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 327
 328   controlRenderer.SetOffStage( actor );
 329   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 330
 331   END_TEST;
 332 }
 333
 334 int UtcDaliRendererFactoryGetBorderRenderer1(void)
 335 {
 336   ToolkitTestApplication application;
 337   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer1:  Request border renderer with a Property::Map" );
 338
 339   RendererFactory factory = RendererFactory::Get();
 340   DALI_TEST_CHECK( factory );
 341
 342   Property::Map propertyMap;
 343   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 344   float testSize = 5.f;
 345   propertyMap.Insert("rendererType",  "border");
 346   propertyMap.Insert("borderColor",  testColor);
 347   propertyMap.Insert("borderSize",  testSize);
 348
 349   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 350   DALI_TEST_CHECK( controlRenderer );
 351
 352   Actor actor = Actor::New();
 353   actor.SetSize(200.f, 200.f);
 354   Stage::GetCurrent().Add( actor );
 355   controlRenderer.SetSize(Vector2(200.f, 200.f));
 356   controlRenderer.SetOnStage( actor );
 357
 358   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 359   int blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLENDING_MODE );
 360   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::ON, TEST_LOCATION );
 361
 362   TestGlAbstraction& gl = application.GetGlAbstraction();
 363
 364   application.SendNotification();
 365   application.Render(0);
 366
 367   Vector4 actualColor(Vector4::ZERO);
 368   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 369   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 370
 371   float actualSize = 0.f;
 372   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 373   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 374
 375   controlRenderer.SetOffStage( actor );
 376   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 377
 378   END_TEST;
 379 }
 380
 381 int UtcDaliRendererFactoryGetBorderRenderer2(void)
 382 {
 383   ToolkitTestApplication application;
 384   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer2:  Request border renderer with a borderSize and a borderColor" );
 385
 386   RendererFactory factory = RendererFactory::Get();
 387   DALI_TEST_CHECK( factory );
 388
 389   Vector4 testColor( 1.f, 0.5f, 0.3f, 1.f );
 390   float testSize = 5.f;
 391
 392   ControlRenderer controlRenderer = factory.GetControlRenderer(testSize, testColor );
 393   DALI_TEST_CHECK( controlRenderer );
 394
 395   Actor actor = Actor::New();
 396   actor.SetSize(200.f, 200.f);
 397   Stage::GetCurrent().Add( actor );
 398   controlRenderer.SetSize(Vector2(200.f, 200.f));
 399   controlRenderer.SetOnStage( actor );
 400
 401   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 402
 403   TestGlAbstraction& gl = application.GetGlAbstraction();
 404
 405   application.SendNotification();
 406   application.Render(0);
 407
 408   int blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLENDING_MODE );
 409   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::AUTO, TEST_LOCATION );
 410
 411   Vector4 actualColor(Vector4::ZERO);
 412   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 413   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 414
 415   float actualSize = 0.f;
 416   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 417   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 418
 419   controlRenderer.SetOffStage( actor );
 420
 421   // enable the anti-aliasing
 422   controlRenderer = factory.GetControlRenderer(testSize, testColor, true );
 423   controlRenderer.SetOnStage( actor );
 424
 425   application.SendNotification();
 426   application.Render(0);
 427   blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLENDING_MODE );
 428   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::ON, TEST_LOCATION );
 429
 430   END_TEST;
 431 }
 432
 433 int UtcDaliRendererFactoryGetLinearGradientRenderer(void)
 434 {
 435   ToolkitTestApplication application;
 436   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 437
 438   RendererFactory factory = RendererFactory::Get();
 439   DALI_TEST_CHECK( factory );
 440
 441   Property::Map propertyMap;
 442   propertyMap.Insert("rendererType",  "gradient");
 443
 444   Vector2 start(-1.f, -1.f);
 445   Vector2 end(1.f, 1.f);
 446   propertyMap.Insert("startPosition",   start);
 447   propertyMap.Insert("endPosition",   end);
 448   propertyMap.Insert("spreadMethod",   "repeat");
 449
 450   Property::Array stopOffsets;
 451   stopOffsets.PushBack( 0.2f );
 452   stopOffsets.PushBack( 0.8f );
 453   propertyMap.Insert("stopOffset",   stopOffsets);
 454
 455   Property::Array stopColors;
 456   stopColors.PushBack( Color::RED );
 457   stopColors.PushBack( Color::GREEN );
 458   propertyMap.Insert("stopColor",   stopColors);
 459
 460   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 461   DALI_TEST_CHECK( controlRenderer );
 462
 463   // A lookup texture is generated and pass to shader as sampler
 464   Actor actor = Actor::New();
 465   TestControlRendererRender( application, actor, controlRenderer, 1u );
 466
 467   controlRenderer.SetOffStage( actor );
 468   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 469
 470   END_TEST;
 471 }
 472
 473 int UtcDaliRendererFactoryGetRadialGradientRenderer(void)
 474 {
 475   ToolkitTestApplication application;
 476   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 477
 478   RendererFactory factory = RendererFactory::Get();
 479   DALI_TEST_CHECK( factory );
 480
 481   Property::Map propertyMap;
 482   propertyMap.Insert("rendererType",  "gradient");
 483
 484   Vector2 center(100.f, 100.f);
 485   float radius = 100.f;
 486   propertyMap.Insert("units",  "userSpace");
 487   propertyMap.Insert("center",  center);
 488   propertyMap.Insert("radius",  radius);
 489
 490   Property::Array stopOffsets;
 491   stopOffsets.PushBack( 0.0f );
 492   stopOffsets.PushBack( 1.f );
 493   propertyMap.Insert("stopOffset",   stopOffsets);
 494
 495   Property::Array stopColors;
 496   stopColors.PushBack( Color::RED );
 497   stopColors.PushBack( Color::GREEN );
 498   propertyMap.Insert("stopColor",   stopColors);
 499
 500   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 501   DALI_TEST_CHECK( controlRenderer );
 502
 503   // A lookup texture is generated and pass to shader as sampler
 504   Actor actor = Actor::New();
 505   TestControlRendererRender( application, actor, controlRenderer, 1u );
 506
 507   Matrix3 alignMatrix( radius, 0.f, 0.f, 0.f, radius, 0.f, center.x, center.y, 1.f );
 508   alignMatrix.Invert();
 509
 510   Matrix3 actualValue( Matrix3::IDENTITY );
 511   TestGlAbstraction& gl = application.GetGlAbstraction();
 512   DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uAlignmentMatrix", actualValue ) );
 513   DALI_TEST_EQUALS( actualValue, alignMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 514
 515   END_TEST;
 516 }
 517
 518 int UtcDaliRendererFactoryDefaultOffsetsGradientRenderer(void)
 519 {
 520   ToolkitTestApplication application;
 521   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 522
 523   RendererFactory factory = RendererFactory::Get();
 524   DALI_TEST_CHECK( factory );
 525
 526   Property::Map propertyMap;
 527   propertyMap.Insert("rendererType",  "gradient");
 528
 529   Vector2 start(-1.f, -1.f);
 530   Vector2 end(1.f, 1.f);
 531   propertyMap.Insert("startPosition",   start);
 532   propertyMap.Insert("endPosition",   end);
 533   propertyMap.Insert("spreadMethod",   "repeat");
 534
 535   Property::Array stopColors;
 536   stopColors.PushBack( Color::RED );
 537   stopColors.PushBack( Color::GREEN );
 538   propertyMap.Insert("stopColor",   stopColors);
 539
 540   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 541   DALI_TEST_CHECK( controlRenderer );
 542
 543   // A lookup texture is generated and pass to shader as sampler
 544   Actor actor = Actor::New();
 545   TestControlRendererRender( application, actor, controlRenderer, 1u );
 546
 547   controlRenderer.SetOffStage( actor );
 548   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 549
 550   END_TEST;
 551 }
 552
 553 int UtcDaliRendererFactoryGetImageRenderer1(void)
 554 {
 555   ToolkitTestApplication application;
 556   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer1: Request image renderer with a Property::Map" );
 557
 558   RendererFactory factory = RendererFactory::Get();
 559   DALI_TEST_CHECK( factory );
 560
 561   Property::Map propertyMap;
 562   propertyMap.Insert( "rendererType",  "image" );
 563   propertyMap.Insert( "imageUrl",  TEST_IMAGE_FILE_NAME );
 564
 565   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 566   DALI_TEST_CHECK( controlRenderer );
 567
 568   Actor actor = Actor::New();
 569   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 570   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 571
 572   const int width=512;
 573   const int height=513;
 574   TestGlAbstraction& gl = application.GetGlAbstraction();
 575   TraceCallStack& textureTrace = gl.GetTextureTrace();
 576   textureTrace.Enable(true);
 577
 578   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 579   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, width, height,width, height );
 580
 581   TestControlRendererRender( application, actor, controlRenderer, 1u,
 582                              ImageDimensions(width, height),
 583                              Integration::ResourcePointer( bitmap ) );
 584
 585   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 586
 587   controlRenderer.SetOffStage( actor );
 588   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 589
 590   END_TEST;
 591 }
 592
 593 int UtcDaliRendererFactoryGetImageRenderer2(void)
 594 {
 595   ToolkitTestApplication application;
 596   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer2: Request image renderer with an image handle" );
 597
 598   RendererFactory factory = RendererFactory::Get();
 599   DALI_TEST_CHECK( factory );
 600
 601   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 602   ControlRenderer controlRenderer = factory.GetControlRenderer( image );
 603
 604   Actor actor = Actor::New();
 605   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 606   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 607
 608   const int width=512;
 609   const int height=513;
 610
 611   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 612   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, width, height,width, height );
 613
 614   TestGlAbstraction& gl = application.GetGlAbstraction();
 615   TraceCallStack& textureTrace = gl.GetTextureTrace();
 616   textureTrace.Enable(true);
 617
 618   TestControlRendererRender( application, actor, controlRenderer, 1u,
 619                              ImageDimensions(width, height),
 620                              Integration::ResourcePointer(bitmap) );
 621
 622   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 623
 624   END_TEST;
 625 }
 626
 627 int UtcDaliRendererFactoryGetNPatchRenderer1(void)
 628 {
 629   ToolkitTestApplication application;
 630   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer1: Request 9-patch renderer with a Property::Map" );
 631
 632   RendererFactory factory = RendererFactory::Get();
 633   DALI_TEST_CHECK( factory );
 634
 635   const unsigned int ninePatchImageHeight = 18;
 636   const unsigned int ninePatchImageWidth = 28;
 637   StretchRanges stretchRangesX;
 638   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 639   StretchRanges stretchRangesY;
 640   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 641   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 642
 643   Property::Map propertyMap;
 644   propertyMap.Insert( "rendererType",  "nPatch" );
 645   propertyMap.Insert( "imageUrl",  TEST_NPATCH_FILE_NAME );
 646   {
 647     tet_infoline( "whole grid" );
 648     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 649     DALI_TEST_CHECK( controlRenderer );
 650
 651     Actor actor = Actor::New();
 652
 653     TestGlAbstraction& gl = application.GetGlAbstraction();
 654     TraceCallStack& textureTrace = gl.GetTextureTrace();
 655     textureTrace.Enable(true);
 656
 657     TestControlRendererRender( application, actor, controlRenderer, 1u,
 658                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 659                                ninePatchResource );
 660
 661     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 662   }
 663
 664   propertyMap.Insert( "borderOnly",  true );
 665   {
 666     tet_infoline( "border only" );
 667     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 668     DALI_TEST_CHECK( controlRenderer );
 669
 670     Actor actor = Actor::New();
 671
 672     TestGlAbstraction& gl = application.GetGlAbstraction();
 673     TraceCallStack& textureTrace = gl.GetTextureTrace();
 674     textureTrace.Enable(true);
 675
 676     TestControlRendererRender( application, actor, controlRenderer, 1u,
 677                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 678                                ninePatchResource );
 679
 680     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 681   }
 682
 683   END_TEST;
 684 }
 685
 686 int UtcDaliRendererFactoryGetNPatchRenderer2(void)
 687 {
 688   ToolkitTestApplication application;
 689   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer2: Request n-patch renderer with a Property::Map" );
 690
 691   RendererFactory factory = RendererFactory::Get();
 692   DALI_TEST_CHECK( factory );
 693
 694   const unsigned int ninePatchImageWidth = 18;
 695   const unsigned int ninePatchImageHeight = 28;
 696   StretchRanges stretchRangesX;
 697   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 698   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 699   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 700   StretchRanges stretchRangesY;
 701   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 702   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 703   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 704   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 705   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 706
 707   Property::Map propertyMap;
 708   propertyMap.Insert( "rendererType",  "nPatch" );
 709   propertyMap.Insert( "imageUrl",  TEST_NPATCH_FILE_NAME );
 710   {
 711     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 712     DALI_TEST_CHECK( controlRenderer );
 713
 714     Actor actor = Actor::New();
 715     TestGlAbstraction& gl = application.GetGlAbstraction();
 716     TraceCallStack& textureTrace = gl.GetTextureTrace();
 717     textureTrace.Enable(true);
 718
 719     TestControlRendererRender( application, actor, controlRenderer, 1u,
 720                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 721                                ninePatchResource );
 722
 723
 724     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 725
 726     controlRenderer.SetOffStage( actor );
 727     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 728   }
 729
 730   propertyMap.Insert( "borderOnly",  true );
 731   {
 732     tet_infoline( "border only" );
 733     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 734     DALI_TEST_CHECK( controlRenderer );
 735
 736     TestGlAbstraction& gl = application.GetGlAbstraction();
 737     TraceCallStack& textureTrace = gl.GetTextureTrace();
 738     textureTrace.Enable(true);
 739     Actor actor = Actor::New();
 740     TestControlRendererRender( application, actor, controlRenderer, 1u,
 741                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 742                                ninePatchResource );
 743
 744
 745     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 746
 747     controlRenderer.SetOffStage( actor );
 748     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 749   }
 750
 751   END_TEST;
 752 }
 753
 754 int UtcDaliRendererFactoryGetNPatchRenderer3(void)
 755 {
 756   ToolkitTestApplication application;
 757   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer3: Request 9-patch renderer with an image url" );
 758
 759   RendererFactory factory = RendererFactory::Get();
 760   DALI_TEST_CHECK( factory );
 761
 762   const unsigned int ninePatchImageHeight = 18;
 763   const unsigned int ninePatchImageWidth = 28;
 764   StretchRanges stretchRangesX;
 765   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 766   StretchRanges stretchRangesY;
 767   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 768   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 769
 770   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
 771   DALI_TEST_CHECK( controlRenderer );
 772
 773   Actor actor = Actor::New();
 774
 775   TestGlAbstraction& gl = application.GetGlAbstraction();
 776   TraceCallStack& textureTrace = gl.GetTextureTrace();
 777   textureTrace.Enable(true);
 778
 779   TestControlRendererRender( application, actor, controlRenderer, 1u,
 780                              ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 781                              ninePatchResource );
 782
 783   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 784
 785   END_TEST;
 786 }
 787
 788 int UtcDaliRendererFactoryGetNPatchRenderer4(void)
 789 {
 790   ToolkitTestApplication application;
 791   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer4: Request n-patch renderer with an image url" );
 792
 793   RendererFactory factory = RendererFactory::Get();
 794   DALI_TEST_CHECK( factory );
 795
 796   const unsigned int ninePatchImageHeight = 18;
 797   const unsigned int ninePatchImageWidth = 28;
 798   StretchRanges stretchRangesX;
 799   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 800   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 801   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 802   StretchRanges stretchRangesY;
 803   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 804   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 805   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 806   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 807   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 808
 809   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
 810   DALI_TEST_CHECK( controlRenderer );
 811
 812   Actor actor = Actor::New();
 813
 814   TestGlAbstraction& gl = application.GetGlAbstraction();
 815   TraceCallStack& textureTrace = gl.GetTextureTrace();
 816   textureTrace.Enable(true);
 817
 818   TestControlRendererRender( application, actor, controlRenderer, 1u,
 819                              ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 820                              ninePatchResource );
 821
 822   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 823
 824   END_TEST;
 825 }
 826
 827 int UtcDaliRendererFactoryGetNPatchRendererN1(void)
 828 {
 829   //This should still load but display an error image
 830
 831   ToolkitTestApplication application;
 832   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid image url" );
 833
 834   RendererFactory factory = RendererFactory::Get();
 835   DALI_TEST_CHECK( factory );
 836
 837   ControlRenderer controlRenderer = factory.GetControlRenderer( "ERROR.9.jpg" );
 838   DALI_TEST_CHECK( controlRenderer );
 839
 840   Actor actor = Actor::New();
 841
 842   //The testkit still has to load a bitmap for the broken renderer image
 843   Integration::Bitmap* bitmap = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD);
 844   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, 100, 100, 100, 100 );
 845
 846   TestGlAbstraction& gl = application.GetGlAbstraction();
 847   TraceCallStack& textureTrace = gl.GetTextureTrace();
 848   textureTrace.Enable(true);
 849
 850   TestControlRendererRender( application, actor, controlRenderer, 1u,
 851                              ImageDimensions(),
 852                              Integration::ResourcePointer(bitmap) );
 853
 854   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 855
 856   END_TEST;
 857 }
 858
 859 int UtcDaliRendererFactoryGetNPatchRendererN2(void)
 860 {
 861   //This should still load but display an error image
 862
 863   ToolkitTestApplication application;
 864   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid Property::Map" );
 865
 866   RendererFactory factory = RendererFactory::Get();
 867   DALI_TEST_CHECK( factory );
 868
 869   Property::Map propertyMap;
 870   propertyMap.Insert( "rendererType",  "nPatch" );
 871   propertyMap.Insert( "imageUrl",  111 );
 872
 873   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 874   DALI_TEST_CHECK( controlRenderer );
 875
 876   Actor actor = Actor::New();
 877
 878   //The testkit still has to load a bitmap for the broken renderer image
 879   Integration::Bitmap* bitmap = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD);
 880   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, 100, 100, 100, 100 );
 881
 882   TestGlAbstraction& gl = application.GetGlAbstraction();
 883   TraceCallStack& textureTrace = gl.GetTextureTrace();
 884   textureTrace.Enable(true);
 885
 886   TestControlRendererRender( application, actor, controlRenderer, 1u,
 887                              ImageDimensions(),
 888                              Integration::ResourcePointer(bitmap) );
 889
 890   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 891
 892   END_TEST;
 893 }
 894
 895 int UtcDaliRendererFactoryGetSvgRenderer(void)
 896 {
 897   ToolkitTestApplication application;
 898   tet_infoline( "UtcDaliRendererFactoryGetSvgRenderer: Request svg renderer with a svg url" );
 899
 900   RendererFactory factory = RendererFactory::Get();
 901   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_SVG_FILE_NAME );
 902   DALI_TEST_CHECK( controlRenderer );
 903
 904   TestGlAbstraction& gl = application.GetGlAbstraction();
 905   TraceCallStack& textureTrace = gl.GetTextureTrace();
 906   textureTrace.Enable(true);
 907
 908   Actor actor = Actor::New();
 909   actor.SetSize( 200.f, 200.f );
 910   Stage::GetCurrent().Add( actor );
 911   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 912   controlRenderer.SetOnStage( actor );
 913   application.SendNotification();
 914   application.Render();
 915
 916   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 917
 918   EventThreadCallback* eventTrigger = EventThreadCallback::Get();
 919   CallbackBase* callback = eventTrigger->GetCallback();
 920
 921   eventTrigger->WaitingForTrigger( 1 );// waiting until the svg image is rasterized.
 922   CallbackBase::Execute( *callback );
 923
 924   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 925
 926   // waiting for the resource uploading
 927   application.SendNotification();
 928   application.Render();
 929
 930   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 931
 932   END_TEST;
 933 }
 934
 935 int UtcDaliRendererFactoryResetRenderer1(void)
 936 {
 937   ToolkitTestApplication application;
 938   tet_infoline( "UtcDaliRendererFactoryResetRenderer1" );
 939
 940   RendererFactory factory = RendererFactory::Get();
 941   DALI_TEST_CHECK( factory );
 942
 943   ControlRenderer controlRenderer = factory.GetControlRenderer( Color::RED );
 944   DALI_TEST_CHECK( controlRenderer );
 945
 946   Actor actor = Actor::New();
 947   TestControlRendererRender( application, actor, controlRenderer );
 948
 949   Vector4 actualValue(Vector4::ZERO);
 950   TestGlAbstraction& gl = application.GetGlAbstraction();
 951   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "blendColor", actualValue ) );
 952   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 953
 954   factory.ResetRenderer( controlRenderer, actor, Color::GREEN );
 955   application.SendNotification();
 956   application.Render(0);
 957   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "blendColor", actualValue ) );
 958   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
 959
 960   Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
 961   factory.ResetRenderer( controlRenderer, actor, bufferImage );
 962
 963   Actor actor2 = Actor::New();
 964   actor2.SetSize(200.f, 200.f);
 965   Stage::GetCurrent().Add( actor2 );
 966   controlRenderer.SetSize(Vector2(200.f, 200.f));
 967   controlRenderer.SetOnStage( actor2 );
 968   application.SendNotification();
 969   application.Render(0);
 970
 971   END_TEST;
 972 }
 973
 974 int UtcDaliRendererFactoryResetRenderer2(void)
 975 {
 976   ToolkitTestApplication application;
 977   tet_infoline( "UtcDaliRendererFactoryResetRenderer2" );
 978
 979   Actor actor = Actor::New();
 980   actor.SetSize(200.f, 200.f);
 981   Stage::GetCurrent().Add( actor );
 982   RendererFactory factory = RendererFactory::Get();
 983   DALI_TEST_CHECK( factory );
 984
 985   Image resourceImage = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 986   ControlRenderer controlRenderer = factory.GetControlRenderer( resourceImage );
 987   DALI_TEST_CHECK( controlRenderer );
 988   controlRenderer.SetSize(Vector2(200.f, 200.f));
 989   controlRenderer.SetOnStage( actor );
 990   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 991
 992   application.SendNotification();
 993   application.Render(0);
 994
 995   Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
 996   factory.ResetRenderer( controlRenderer, actor, bufferImage );
 997   application.SendNotification();
 998   application.Render(0);
 999
1000   factory.ResetRenderer( controlRenderer, actor, Color::RED );
1001
1002   Actor actor2 = Actor::New();
1003   actor2.SetSize(200.f, 200.f);
1004   Stage::GetCurrent().Add( actor2 );
1005   controlRenderer.SetSize(Vector2(200.f, 200.f));
1006   controlRenderer.SetOnStage( actor2 );
1007   TestGlAbstraction& gl = application.GetGlAbstraction();
1008   application.SendNotification();
1009   application.Render(0);
1010   Vector4 actualValue(Vector4::ZERO);
1011   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "blendColor", actualValue ) );
1012   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
1013
1014   END_TEST;
1015 }
1016
1017 int UtcDaliRendererFactoryResetRenderer3(void)
1018 {
1019   ToolkitTestApplication application;
1020   tet_infoline( "UtcDaliRendererFactoryResetRenderer3" );
1021
1022   Actor actor = Actor::New();
1023   actor.SetSize(200.f, 200.f);
1024   Stage::GetCurrent().Add( actor );
1025   RendererFactory factory = RendererFactory::Get();
1026   DALI_TEST_CHECK( factory );
1027
1028   // Get renderer for rendering a resource image
1029   Image resourceImage = ResourceImage::New(TEST_IMAGE_FILE_NAME);
1030   ControlRenderer controlRenderer = factory.GetControlRenderer( resourceImage );
1031   DALI_TEST_CHECK( controlRenderer );
1032   controlRenderer.SetSize(Vector2(200.f, 200.f));
1033   controlRenderer.SetOnStage( actor );
1034   application.SendNotification();
1035   application.Render();
1036
1037   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1038
1039   // reset the renderer to renderer a svg image
1040   factory.ResetRenderer( controlRenderer, actor, TEST_SVG_FILE_NAME, ImageDimensions( 100, 100 ) );
1041   application.SendNotification();
1042   application.Render();
1043
1044   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1045
1046   EventThreadCallback* eventTrigger = EventThreadCallback::Get();
1047   CallbackBase* callback = eventTrigger->GetCallback();
1048
1049   eventTrigger->WaitingForTrigger( 1 );// waiting until the svg image is rasterized.
1050   CallbackBase::Execute( *callback );
1051
1052   END_TEST;
1053 }