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 <dali/devel-api/rendering/renderer.h>
  21 #include <dali/devel-api/rendering/material.h>
  22 #include <dali/devel-api/rendering/shader.h>
  23 #include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
  24
  25 using namespace Dali;
  26 using namespace Dali::Toolkit;
  27
  28 namespace
  29 {
  30 typedef NinePatchImage::StretchRanges StretchRanges;
  31
  32 const char* TEST_IMAGE_FILE_NAME =  "gallery_image_01.jpg";
  33 const char* TEST_NPATCH_FILE_NAME =  "gallery_image_01.9.jpg";
  34
  35 Integration::Bitmap* CreateBitmap( unsigned int imageWidth, unsigned int imageHeight, unsigned int initialColor, Pixel::Format pixelFormat )
  36 {
  37   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
  38   Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
  39   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  40
  41   memset( pixbuffer, initialColor, imageHeight * imageWidth * bytesPerPixel );
  42
  43   return bitmap;
  44 }
  45
  46 void InitialiseRegionsToZeroAlpha( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
  47 {
  48   PixelBuffer* pixbuffer = image->GetBuffer();
  49   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  50
  51   for( unsigned int row = 0; row < imageWidth; ++row )
  52   {
  53     unsigned int pixelOffset = row * bytesPerPixel;
  54     pixbuffer[ pixelOffset + 3 ] = 0x00;
  55     pixelOffset += ( imageHeight - 1 ) * imageWidth * bytesPerPixel;
  56     pixbuffer[ pixelOffset + 3 ] = 0x00;
  57   }
  58
  59   for ( unsigned int column = 0; column < imageHeight; ++column )
  60   {
  61     unsigned int pixelOffset = column * imageWidth * bytesPerPixel;
  62     pixbuffer[ pixelOffset + 3 ] = 0x00;
  63     pixelOffset += ( imageWidth -1 ) * bytesPerPixel;
  64     pixbuffer[ pixelOffset + 3 ] = 0x00;
  65   }
  66 }
  67
  68 void AddStretchRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const StretchRanges& stretchRangesX, const StretchRanges& stretchRangesY, Pixel::Format pixelFormat )
  69 {
  70   PixelBuffer* pixbuffer = image->GetBuffer();
  71   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  72
  73   for(StretchRanges::ConstIterator it = stretchRangesX.Begin(); it != stretchRangesX.End(); ++it)
  74   {
  75     const Uint16Pair& range = *it;
  76     //since the stretch range is in the cropped image space, we need to offset by 1 to get it to the uncropped image space
  77     for( unsigned int column = range.GetX() + 1u; column < range.GetY() + 1u; ++column )
  78     {
  79       unsigned int pixelOffset = column * bytesPerPixel;
  80       pixbuffer[ pixelOffset ] = 0x00;
  81       pixbuffer[ pixelOffset + 1 ] = 0x00;
  82       pixbuffer[ pixelOffset + 2 ] = 0x00;
  83       pixbuffer[ pixelOffset + 3 ] = 0xFF;
  84     }
  85   }
  86
  87
  88   for(StretchRanges::ConstIterator it = stretchRangesY.Begin(); it != stretchRangesY.End(); ++it)
  89   {
  90     const Uint16Pair& range = *it;
  91     //since the stretch range is in the cropped image space, we need to offset by 1 to get it to the uncropped image space
  92     for( unsigned int row = range.GetX() + 1u; row < range.GetY() + 1u; ++row )
  93     {
  94       unsigned int pixelOffset = row * imageWidth * bytesPerPixel;
  95       pixbuffer[ pixelOffset ] = 0x00;
  96       pixbuffer[ pixelOffset + 1 ] = 0x00;
  97       pixbuffer[ pixelOffset + 2 ] = 0x00;
  98       pixbuffer[ pixelOffset + 3 ] = 0xFF;
  99     }
 100   }
 101 }
 102
 103 void AddChildRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const Vector4& requiredChildRegion, Pixel::Format pixelFormat )
 104 {
 105   PixelBuffer* pixbuffer = image->GetBuffer();
 106   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
 107
 108   Integration::Bitmap::PackedPixelsProfile* srcProfile = image->GetPackedPixelsProfile();
 109   unsigned int bufferStride = srcProfile->GetBufferStride();
 110
 111   // Add bottom child region
 112   for( unsigned int column = requiredChildRegion.x; column < imageWidth - requiredChildRegion.z; ++column )
 113   {
 114     unsigned int pixelOffset = column * bytesPerPixel;
 115     pixelOffset += ( imageHeight - 1 ) * bufferStride;
 116     pixbuffer[ pixelOffset ] = 0x00;
 117     pixbuffer[ pixelOffset + 1 ] = 0x00;
 118     pixbuffer[ pixelOffset + 2 ] = 0x00;
 119     pixbuffer[ pixelOffset + 3 ] = 0xFF;
 120   }
 121
 122   // Add right child region
 123   for ( unsigned int row = requiredChildRegion.y; row < imageHeight - requiredChildRegion.w; ++row )
 124   {
 125     unsigned int pixelOffset = row * bufferStride + ( imageWidth - 1 ) * bytesPerPixel;
 126     pixbuffer[ pixelOffset ] = 0x00;
 127     pixbuffer[ pixelOffset + 1 ] = 0x00;
 128     pixbuffer[ pixelOffset + 2 ] = 0x00;
 129     pixbuffer[ pixelOffset + 3 ] = 0xFF;
 130   }
 131 }
 132
 133 Integration::ResourcePointer CustomizeNinePatch( TestApplication& application,
 134                                                  unsigned int ninePatchImageWidth,
 135                                                  unsigned int ninePatchImageHeight,
 136                                                  const StretchRanges& stretchRangesX,
 137                                                  const StretchRanges& stretchRangesY,
 138                                                  bool addChildRegion = false,
 139                                                  Vector4 requiredChildRegion = Vector4::ZERO )
 140 {
 141   TestPlatformAbstraction& platform = application.GetPlatform();
 142
 143   Pixel::Format pixelFormat = Pixel::RGBA8888;
 144
 145   tet_infoline("Create Bitmap");
 146   platform.SetClosestImageSize(Vector2( ninePatchImageWidth, ninePatchImageHeight));
 147   Integration::Bitmap* bitmap = CreateBitmap( ninePatchImageWidth, ninePatchImageHeight, 0xFF, pixelFormat );
 148
 149   tet_infoline("Clear border regions");
 150   InitialiseRegionsToZeroAlpha( bitmap, ninePatchImageWidth, ninePatchImageHeight, pixelFormat );
 151
 152   tet_infoline("Add Stretch regions to Bitmap");
 153   AddStretchRegionsToImage( bitmap, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY, pixelFormat );
 154
 155   if( addChildRegion )
 156   {
 157     tet_infoline("Add Child regions to Bitmap");
 158     AddChildRegionsToImage( bitmap, ninePatchImageWidth, ninePatchImageHeight, requiredChildRegion, pixelFormat );
 159   }
 160
 161   tet_infoline("Getting resource");
 162   Integration::ResourcePointer resourcePtr(bitmap);
 163   platform.SetResourceLoaded( 0, Dali::Integration::ResourceBitmap, resourcePtr );
 164
 165   return resourcePtr;
 166 }
 167
 168 void TestControlRendererRender( ToolkitTestApplication& application, Actor& actor, ControlRenderer& controlRenderer, Integration::ResourcePointer resourcePtr = Integration::ResourcePointer(), std::size_t expectedSamplers = 0)
 169 {
 170   actor.SetSize( 200.f, 200.f );
 171   Stage::GetCurrent().Add( actor );
 172   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 173   controlRenderer.SetOnStage( actor );
 174
 175   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 176   DALI_TEST_CHECK( actor.GetRendererAt(0u).GetMaterial().GetNumberOfTextures() == expectedSamplers );
 177
 178   application.SendNotification();
 179   application.Render();
 180
 181   if( resourcePtr )
 182   {
 183     Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
 184     if(request)
 185     {
 186       application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, resourcePtr );
 187     }
 188   }
 189
 190   application.Render();
 191   application.SendNotification();
 192
 193   if( resourcePtr )
 194   {
 195     DALI_TEST_CHECK(application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc));
 196   }
 197
 198   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 199
 200 }
 201
 202 } // namespace
 203
 204
 205 void dali_renderer_factory_startup(void)
 206 {
 207   test_return_value = TET_UNDEF;
 208 }
 209
 210 void dali_renderer_factory_cleanup(void)
 211 {
 212   test_return_value = TET_PASS;
 213 }
 214
 215 int UtcDaliRendererFactoryGet(void)
 216 {
 217   ToolkitTestApplication application;
 218   tet_infoline( "UtcDaliRendererFactory" );
 219
 220   //Register type
 221   TypeInfo type;
 222   type = TypeRegistry::Get().GetTypeInfo( "RendererFactory" );
 223   DALI_TEST_CHECK( type );
 224   BaseHandle handle = type.CreateInstance();
 225   DALI_TEST_CHECK( handle );
 226
 227   RendererFactory factory;
 228   factory = RendererFactory::Get();
 229   DALI_TEST_CHECK( factory );
 230
 231   RendererFactory newFactory = RendererFactory::Get();
 232   DALI_TEST_CHECK( newFactory );
 233
 234   // Check that renderer factory is a singleton
 235   DALI_TEST_CHECK(factory == newFactory);
 236
 237   END_TEST;
 238 }
 239
 240 int UtcDaliRendererFactoryCopyAndAssignment(void)
 241 {
 242   ToolkitTestApplication application;
 243   tet_infoline( "UtcDaliRendererFactoryCopyAndAssignment" );
 244   RendererFactory factory = RendererFactory::Get();
 245
 246   RendererFactory factoryCopy( factory );
 247   DALI_TEST_CHECK(factory == factoryCopy);
 248
 249   RendererFactory emptyFactory;
 250   RendererFactory emptyFactoryCopy( emptyFactory );
 251   DALI_TEST_CHECK(emptyFactory == emptyFactoryCopy);
 252
 253   RendererFactory factoryEquals;
 254   factoryEquals = factory;
 255   DALI_TEST_CHECK(factory == factoryEquals);
 256
 257   RendererFactory emptyFactoryEquals;
 258   emptyFactoryEquals = emptyFactory;
 259   DALI_TEST_CHECK( emptyFactory == emptyFactoryEquals );
 260
 261   //self assignment
 262   factory = factory;
 263   DALI_TEST_CHECK( factory = factoryCopy );
 264
 265   END_TEST;
 266 }
 267
 268 int UtcDaliRendererFactoryGetColorRenderer1(void)
 269 {
 270   ToolkitTestApplication application;
 271   tet_infoline( "UtcDaliRendererFactoryGetColorRenderer1:  Request color renderer with a Property::Map" );
 272
 273   RendererFactory factory = RendererFactory::Get();
 274   DALI_TEST_CHECK( factory );
 275
 276   Property::Map propertyMap;
 277   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 278   propertyMap.Insert("renderer-type", "color-renderer");
 279   propertyMap.Insert("blend-color", testColor);
 280
 281   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 282   DALI_TEST_CHECK( controlRenderer );
 283
 284   Actor actor = Actor::New();
 285   TestControlRendererRender( application, actor, controlRenderer );
 286
 287   Vector4 actualValue(Vector4::ZERO);
 288   TestGlAbstraction& gl = application.GetGlAbstraction();
 289   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBlendColor", actualValue ) );
 290   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 291
 292   END_TEST;
 293 }
 294
 295 int UtcDaliRendererFactoryGetColorRenderer2(void)
 296 {
 297   ToolkitTestApplication application;
 298   tet_infoline( "UtcDaliRendererFactoryGetColorRenderer2: Request color renderer with a Vector4" );
 299
 300   RendererFactory factory = RendererFactory::Get();
 301   DALI_TEST_CHECK( factory );
 302
 303   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 304   ControlRenderer controlRenderer = factory.GetControlRenderer(testColor);
 305   DALI_TEST_CHECK( controlRenderer );
 306
 307   Actor actor = Actor::New();
 308   TestControlRendererRender( application, actor, controlRenderer );
 309
 310   Vector4 actualValue(Vector4::ZERO);
 311   TestGlAbstraction& gl = application.GetGlAbstraction();
 312   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBlendColor", actualValue ) );
 313   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 314
 315   controlRenderer.SetOffStage( actor );
 316   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 317
 318   END_TEST;
 319 }
 320
 321 int UtcDaliRendererFactoryGetBorderRenderer1(void)
 322 {
 323   ToolkitTestApplication application;
 324   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer1:  Request border renderer with a Property::Map" );
 325
 326   RendererFactory factory = RendererFactory::Get();
 327   DALI_TEST_CHECK( factory );
 328
 329   Property::Map propertyMap;
 330   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 331   float testSize = 5.f;
 332   propertyMap.Insert("renderer-type", "border-renderer");
 333   propertyMap.Insert("border-color", testColor);
 334   propertyMap.Insert("border-size", testSize);
 335
 336   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 337   DALI_TEST_CHECK( controlRenderer );
 338
 339   Actor actor = Actor::New();
 340   actor.SetSize(200.f, 200.f);
 341   Stage::GetCurrent().Add( actor );
 342   controlRenderer.SetSize(Vector2(200.f, 200.f));
 343   controlRenderer.SetOnStage( actor );
 344
 345   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 346
 347   TestGlAbstraction& gl = application.GetGlAbstraction();
 348
 349   application.SendNotification();
 350   application.Render(0);
 351
 352   Vector4 actualColor(Vector4::ZERO);
 353   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBorderColor", actualColor ) );
 354   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 355
 356   float actualSize = 0.f;
 357   DALI_TEST_CHECK( gl.GetUniformValue<float>( "uBorderSize", actualSize ) );
 358   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 359
 360   controlRenderer.SetOffStage( actor );
 361   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 362
 363   END_TEST;
 364 }
 365
 366 int UtcDaliRendererFactoryGetBorderRenderer2(void)
 367 {
 368   ToolkitTestApplication application;
 369   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer2:  Request border renderer with a borderSize and a borderColor" );
 370
 371   RendererFactory factory = RendererFactory::Get();
 372   DALI_TEST_CHECK( factory );
 373
 374   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 375   float testSize = 5.f;
 376
 377   ControlRenderer controlRenderer = factory.GetControlRenderer(testSize, testColor);
 378   DALI_TEST_CHECK( controlRenderer );
 379
 380   Actor actor = Actor::New();
 381   actor.SetSize(200.f, 200.f);
 382   Stage::GetCurrent().Add( actor );
 383   controlRenderer.SetSize(Vector2(200.f, 200.f));
 384   controlRenderer.SetOnStage( actor );
 385
 386   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 387
 388   TestGlAbstraction& gl = application.GetGlAbstraction();
 389
 390   application.SendNotification();
 391   application.Render(0);
 392
 393   Vector4 actualColor(Vector4::ZERO);
 394   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBorderColor", actualColor ) );
 395   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 396
 397   float actualSize = 0.f;
 398   DALI_TEST_CHECK( gl.GetUniformValue<float>( "uBorderSize", actualSize ) );
 399   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 400
 401   END_TEST;
 402 }
 403
 404
 405 int UtcDaliRendererFactoryGetLinearGradientRenderer(void)
 406 {
 407   ToolkitTestApplication application;
 408   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 409
 410   RendererFactory factory = RendererFactory::Get();
 411   DALI_TEST_CHECK( factory );
 412
 413   Property::Map propertyMap;
 414   propertyMap.Insert("renderer-type", "gradient-renderer");
 415
 416   Vector2 start(-1.f, -1.f);
 417   Vector2 end(1.f, 1.f);
 418   propertyMap.Insert("gradient-start-position", start);
 419   propertyMap.Insert("gradient-end-position", end);
 420   propertyMap.Insert("gradient-spread-method", "repeat");
 421
 422   Property::Array stopOffsets;
 423   stopOffsets.PushBack( 0.2f );
 424   stopOffsets.PushBack( 0.8f );
 425   propertyMap.Insert("gradient-stop-offset", stopOffsets);
 426
 427   Property::Array stopColors;
 428   stopColors.PushBack( Color::RED );
 429   stopColors.PushBack( Color::GREEN );
 430   propertyMap.Insert("gradient-stop-color", stopColors);
 431
 432   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 433   DALI_TEST_CHECK( controlRenderer );
 434
 435   // A lookup texture is generated and pass to shader as sampler
 436   Actor actor = Actor::New();
 437   TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(), 1u );
 438
 439   controlRenderer.SetOffStage( actor );
 440   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 441
 442   END_TEST;
 443 }
 444
 445 int UtcDaliRendererFactoryGetRadialGradientRenderer(void)
 446 {
 447   ToolkitTestApplication application;
 448   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 449
 450   RendererFactory factory = RendererFactory::Get();
 451   DALI_TEST_CHECK( factory );
 452
 453   Property::Map propertyMap;
 454   propertyMap.Insert("renderer-type", "gradient-renderer");
 455
 456   Vector2 center(100.f, 100.f);
 457   float radius = 100.f;
 458   propertyMap.Insert("gradient-units", "user-space");
 459   propertyMap.Insert("gradient-center", center);
 460   propertyMap.Insert("gradient-radius", radius);
 461
 462   Property::Array stopOffsets;
 463   stopOffsets.PushBack( 0.0f );
 464   stopOffsets.PushBack( 1.f );
 465   propertyMap.Insert("gradient-stop-offset", stopOffsets);
 466
 467   Property::Array stopColors;
 468   stopColors.PushBack( Color::RED );
 469   stopColors.PushBack( Color::GREEN );
 470   propertyMap.Insert("gradient-stop-color", stopColors);
 471
 472   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 473   DALI_TEST_CHECK( controlRenderer );
 474
 475   // A lookup texture is generated and pass to shader as sampler
 476   Actor actor = Actor::New();
 477   TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(), 1u );
 478
 479   Matrix3 alignMatrix( radius, 0.f, 0.f, 0.f, radius, 0.f, center.x, center.y, 1.f );
 480   alignMatrix.Invert();
 481
 482   Matrix3 actualValue( Matrix3::IDENTITY );
 483   TestGlAbstraction& gl = application.GetGlAbstraction();
 484   DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uAlignmentMatrix", actualValue ) );
 485   DALI_TEST_EQUALS( actualValue, alignMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 486
 487   END_TEST;
 488 }
 489
 490 int UtcDaliRendererFactoryGetImageRenderer1(void)
 491 {
 492   ToolkitTestApplication application;
 493   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer1: Request image renderer with a Property::Map" );
 494
 495   RendererFactory factory = RendererFactory::Get();
 496   DALI_TEST_CHECK( factory );
 497
 498   Property::Map propertyMap;
 499   propertyMap.Insert( "renderer-type", "image-renderer" );
 500   propertyMap.Insert( "image-url", TEST_IMAGE_FILE_NAME );
 501
 502   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 503   DALI_TEST_CHECK( controlRenderer );
 504
 505   Actor actor = Actor::New();
 506   TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)), 1u );
 507
 508   TestGlAbstraction& gl = application.GetGlAbstraction();
 509   int textureUnit = -1;
 510   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 511   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 512
 513   controlRenderer.SetOffStage( actor );
 514   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 515
 516   END_TEST;
 517 }
 518
 519 int UtcDaliRendererFactoryGetImageRenderer2(void)
 520 {
 521   ToolkitTestApplication application;
 522   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer2: Request image renderer with an image handle" );
 523
 524   RendererFactory factory = RendererFactory::Get();
 525   DALI_TEST_CHECK( factory );
 526
 527   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 528   ControlRenderer controlRenderer = factory.GetControlRenderer( image );
 529
 530   Actor actor = Actor::New();
 531   TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)), 1u );
 532
 533   TestGlAbstraction& gl = application.GetGlAbstraction();
 534   int textureUnit = -1;
 535   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 536   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 537
 538   END_TEST;
 539 }
 540
 541 int UtcDaliRendererFactoryGetNPatchRenderer1(void)
 542 {
 543   ToolkitTestApplication application;
 544   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer1: Request 9-patch renderer with a Property::Map" );
 545
 546   RendererFactory factory = RendererFactory::Get();
 547   DALI_TEST_CHECK( factory );
 548
 549   const unsigned int ninePatchImageHeight = 18;
 550   const unsigned int ninePatchImageWidth = 28;
 551   StretchRanges stretchRangesX;
 552   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 553   StretchRanges stretchRangesY;
 554   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 555   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 556
 557   Property::Map propertyMap;
 558   propertyMap.Insert( "renderer-type", "n-patch-renderer" );
 559   propertyMap.Insert( "image-url", TEST_NPATCH_FILE_NAME );
 560   {
 561     tet_infoline( "whole grid" );
 562     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 563     DALI_TEST_CHECK( controlRenderer );
 564
 565     Actor actor = Actor::New();
 566     TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
 567
 568     TestGlAbstraction& gl = application.GetGlAbstraction();
 569     int textureUnit = -1;
 570     DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 571     DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 572   }
 573
 574   propertyMap.Insert( "border-only", true );
 575   {
 576     tet_infoline( "border only" );
 577     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 578     DALI_TEST_CHECK( controlRenderer );
 579
 580     Actor actor = Actor::New();
 581     TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
 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
 589   END_TEST;
 590 }
 591
 592 int UtcDaliRendererFactoryGetNPatchRenderer2(void)
 593 {
 594   ToolkitTestApplication application;
 595   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer2: Request n-patch renderer with a Property::Map" );
 596
 597   RendererFactory factory = RendererFactory::Get();
 598   DALI_TEST_CHECK( factory );
 599
 600   const unsigned int ninePatchImageWidth = 18;
 601   const unsigned int ninePatchImageHeight = 28;
 602   StretchRanges stretchRangesX;
 603   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 604   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 605   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 606   StretchRanges stretchRangesY;
 607   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 608   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 609   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 610   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 611   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 612
 613   Property::Map propertyMap;
 614   propertyMap.Insert( "renderer-type", "n-patch-renderer" );
 615   propertyMap.Insert( "image-url", TEST_NPATCH_FILE_NAME );
 616   {
 617     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 618     DALI_TEST_CHECK( controlRenderer );
 619
 620     Actor actor = Actor::New();
 621     TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
 622
 623     TestGlAbstraction& gl = application.GetGlAbstraction();
 624     int textureUnit = -1;
 625     DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 626     DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 627
 628     controlRenderer.SetOffStage( actor );
 629     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 630   }
 631
 632   propertyMap.Insert( "border-only", true );
 633   {
 634     tet_infoline( "border only" );
 635     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 636     DALI_TEST_CHECK( controlRenderer );
 637
 638     Actor actor = Actor::New();
 639     TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
 640
 641     TestGlAbstraction& gl = application.GetGlAbstraction();
 642     int textureUnit = -1;
 643     DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 644     DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 645
 646     controlRenderer.SetOffStage( actor );
 647     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 648   }
 649
 650   END_TEST;
 651 }
 652
 653 int UtcDaliRendererFactoryGetNPatchRenderer3(void)
 654 {
 655   ToolkitTestApplication application;
 656   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer3: Request 9-patch renderer with an image url" );
 657
 658   RendererFactory factory = RendererFactory::Get();
 659   DALI_TEST_CHECK( factory );
 660
 661   const unsigned int ninePatchImageHeight = 18;
 662   const unsigned int ninePatchImageWidth = 28;
 663   StretchRanges stretchRangesX;
 664   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 665   StretchRanges stretchRangesY;
 666   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 667   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 668
 669   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
 670   DALI_TEST_CHECK( controlRenderer );
 671
 672   Actor actor = Actor::New();
 673   TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
 674
 675   TestGlAbstraction& gl = application.GetGlAbstraction();
 676   int textureUnit = -1;
 677   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 678   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 679
 680   END_TEST;
 681 }
 682
 683 int UtcDaliRendererFactoryGetNPatchRenderer4(void)
 684 {
 685   ToolkitTestApplication application;
 686   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer4: Request n-patch renderer with an image url" );
 687
 688   RendererFactory factory = RendererFactory::Get();
 689   DALI_TEST_CHECK( factory );
 690
 691   const unsigned int ninePatchImageHeight = 18;
 692   const unsigned int ninePatchImageWidth = 28;
 693   StretchRanges stretchRangesX;
 694   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 695   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 696   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 697   StretchRanges stretchRangesY;
 698   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 699   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 700   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 701   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 702   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 703
 704   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
 705   DALI_TEST_CHECK( controlRenderer );
 706
 707   Actor actor = Actor::New();
 708   TestControlRendererRender( application, actor, controlRenderer, ninePatchResource, 1u );
 709
 710   TestGlAbstraction& gl = application.GetGlAbstraction();
 711   int textureUnit = -1;
 712   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 713   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 714
 715   END_TEST;
 716 }
 717
 718 int UtcDaliRendererFactoryGetNPatchRendererN1(void)
 719 {
 720   //This should still load but display an error image
 721
 722   ToolkitTestApplication application;
 723   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid image url" );
 724
 725   RendererFactory factory = RendererFactory::Get();
 726   DALI_TEST_CHECK( factory );
 727
 728   ControlRenderer controlRenderer = factory.GetControlRenderer( "ERROR.9.jpg" );
 729   DALI_TEST_CHECK( controlRenderer );
 730
 731   Actor actor = Actor::New();
 732   //The testkit still has to load a bitmap for the broken renderer image
 733   TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)), 1u );
 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   END_TEST;
 741 }
 742
 743 int UtcDaliRendererFactoryGetNPatchRendererN2(void)
 744 {
 745   //This should still load but display an error image
 746
 747   ToolkitTestApplication application;
 748   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid Property::Map" );
 749
 750   RendererFactory factory = RendererFactory::Get();
 751   DALI_TEST_CHECK( factory );
 752
 753   Property::Map propertyMap;
 754   propertyMap.Insert( "renderer-type", "n-patch-renderer" );
 755   propertyMap.Insert( "image-url", 111 );
 756
 757   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 758   DALI_TEST_CHECK( controlRenderer );
 759
 760   Actor actor = Actor::New();
 761   //The testkit still has to load a bitmap for the broken renderer image
 762   TestControlRendererRender( application, actor, controlRenderer, Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)), 1u );
 763
 764   TestGlAbstraction& gl = application.GetGlAbstraction();
 765   int textureUnit = -1;
 766   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 767   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 768
 769   END_TEST;
 770 }
 771
 772 int UtcDaliRendererFactoryResetRenderer1(void)
 773 {
 774   ToolkitTestApplication application;
 775   tet_infoline( "UtcDaliRendererFactoryResetRenderer1" );
 776
 777   RendererFactory factory = RendererFactory::Get();
 778   DALI_TEST_CHECK( factory );
 779
 780   ControlRenderer controlRenderer = factory.GetControlRenderer( Color::RED );
 781   DALI_TEST_CHECK( controlRenderer );
 782
 783   Actor actor = Actor::New();
 784   TestControlRendererRender( application, actor, controlRenderer );
 785
 786   Vector4 actualValue(Vector4::ZERO);
 787   TestGlAbstraction& gl = application.GetGlAbstraction();
 788   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBlendColor", actualValue ) );
 789   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 790
 791   factory.ResetRenderer( controlRenderer, actor, Color::GREEN );
 792   application.SendNotification();
 793   application.Render(0);
 794   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBlendColor", actualValue ) );
 795   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
 796
 797   Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
 798   factory.ResetRenderer( controlRenderer, actor, bufferImage );
 799
 800   Actor actor2 = Actor::New();
 801   actor2.SetSize(200.f, 200.f);
 802   Stage::GetCurrent().Add( actor2 );
 803   controlRenderer.SetSize(Vector2(200.f, 200.f));
 804   controlRenderer.SetOnStage( actor2 );
 805   application.SendNotification();
 806   application.Render(0);
 807
 808   END_TEST;
 809 }
 810
 811 int UtcDaliRendererFactoryResetRenderer2(void)
 812 {
 813   ToolkitTestApplication application;
 814   tet_infoline( "UtcDaliRendererFactoryResetRenderer2" );
 815
 816   Actor actor = Actor::New();
 817   actor.SetSize(200.f, 200.f);
 818   Stage::GetCurrent().Add( actor );
 819   RendererFactory factory = RendererFactory::Get();
 820   DALI_TEST_CHECK( factory );
 821
 822   Image resourceImage = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 823   ControlRenderer controlRenderer = factory.GetControlRenderer( resourceImage );
 824   DALI_TEST_CHECK( controlRenderer );
 825   controlRenderer.SetSize(Vector2(200.f, 200.f));
 826   controlRenderer.SetOnStage( actor );
 827   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 828
 829   application.SendNotification();
 830   application.Render(0);
 831
 832   Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
 833   factory.ResetRenderer( controlRenderer, actor, bufferImage );
 834   application.SendNotification();
 835   application.Render(0);
 836
 837   factory.ResetRenderer( controlRenderer, actor, Color::RED );
 838
 839   Actor actor2 = Actor::New();
 840   actor2.SetSize(200.f, 200.f);
 841   Stage::GetCurrent().Add( actor2 );
 842   controlRenderer.SetSize(Vector2(200.f, 200.f));
 843   controlRenderer.SetOnStage( actor2 );
 844   TestGlAbstraction& gl = application.GetGlAbstraction();
 845   application.SendNotification();
 846   application.Render(0);
 847   Vector4 actualValue(Vector4::ZERO);
 848   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBlendColor", actualValue ) );
 849   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 850
 851   END_TEST;
 852 }