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