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