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