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

   1 /*
   2  * Copyright (c) 2016 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/public-api/rendering/renderer.h>
  22 #include <dali/public-api/rendering/texture-set.h>
  23 #include <dali/public-api/rendering/shader.h>
  24 #include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
  25
  26 using namespace Dali;
  27 using namespace Dali::Toolkit;
  28
  29 namespace
  30 {
  31 typedef NinePatchImage::StretchRanges StretchRanges;
  32
  33 const char* TEST_IMAGE_FILE_NAME =  "gallery_image_01.jpg";
  34 const char* TEST_NPATCH_FILE_NAME =  "gallery_image_01.9.png";
  35
  36 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
  37 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
  38 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
  39 const char* TEST_SIMPLE_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube-Points-Only.obj";
  40 const char* TEST_SIMPLE_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal-Simple.mtl";
  41
  42 Integration::Bitmap* CreateBitmap( unsigned int imageWidth, unsigned int imageHeight, unsigned int initialColor, Pixel::Format pixelFormat )
  43 {
  44   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
  45   Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
  46   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  47
  48   memset( pixbuffer, initialColor, imageHeight * imageWidth * bytesPerPixel );
  49
  50   return bitmap;
  51 }
  52
  53 void InitialiseRegionsToZeroAlpha( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
  54 {
  55   PixelBuffer* pixbuffer = image->GetBuffer();
  56   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  57
  58   for( unsigned int row = 0; row < imageWidth; ++row )
  59   {
  60     unsigned int pixelOffset = row * bytesPerPixel;
  61     pixbuffer[ pixelOffset + 3 ] = 0x00;
  62     pixelOffset += ( imageHeight - 1 ) * imageWidth * bytesPerPixel;
  63     pixbuffer[ pixelOffset + 3 ] = 0x00;
  64   }
  65
  66   for ( unsigned int column = 0; column < imageHeight; ++column )
  67   {
  68     unsigned int pixelOffset = column * imageWidth * bytesPerPixel;
  69     pixbuffer[ pixelOffset + 3 ] = 0x00;
  70     pixelOffset += ( imageWidth -1 ) * bytesPerPixel;
  71     pixbuffer[ pixelOffset + 3 ] = 0x00;
  72   }
  73 }
  74
  75 void AddStretchRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const StretchRanges& stretchRangesX, const StretchRanges& stretchRangesY, Pixel::Format pixelFormat )
  76 {
  77   PixelBuffer* pixbuffer = image->GetBuffer();
  78   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  79
  80   for(StretchRanges::ConstIterator it = stretchRangesX.Begin(); it != stretchRangesX.End(); ++it)
  81   {
  82     const Uint16Pair& range = *it;
  83     //since the stretch range is in the cropped image space, we need to offset by 1 to get it to the uncropped image space
  84     for( unsigned int column = range.GetX() + 1u; column < range.GetY() + 1u; ++column )
  85     {
  86       unsigned int pixelOffset = column * bytesPerPixel;
  87       pixbuffer[ pixelOffset ] = 0x00;
  88       pixbuffer[ pixelOffset + 1 ] = 0x00;
  89       pixbuffer[ pixelOffset + 2 ] = 0x00;
  90       pixbuffer[ pixelOffset + 3 ] = 0xFF;
  91     }
  92   }
  93
  94
  95   for(StretchRanges::ConstIterator it = stretchRangesY.Begin(); it != stretchRangesY.End(); ++it)
  96   {
  97     const Uint16Pair& range = *it;
  98     //since the stretch range is in the cropped image space, we need to offset by 1 to get it to the uncropped image space
  99     for( unsigned int row = range.GetX() + 1u; row < range.GetY() + 1u; ++row )
 100     {
 101       unsigned int pixelOffset = row * imageWidth * bytesPerPixel;
 102       pixbuffer[ pixelOffset ] = 0x00;
 103       pixbuffer[ pixelOffset + 1 ] = 0x00;
 104       pixbuffer[ pixelOffset + 2 ] = 0x00;
 105       pixbuffer[ pixelOffset + 3 ] = 0xFF;
 106     }
 107   }
 108 }
 109
 110 void AddChildRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const Vector4& requiredChildRegion, Pixel::Format pixelFormat )
 111 {
 112   PixelBuffer* pixbuffer = image->GetBuffer();
 113   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
 114
 115   Integration::Bitmap::PackedPixelsProfile* srcProfile = image->GetPackedPixelsProfile();
 116   unsigned int bufferStride = srcProfile->GetBufferStride();
 117
 118   // Add bottom child region
 119   for( unsigned int column = requiredChildRegion.x; column < imageWidth - requiredChildRegion.z; ++column )
 120   {
 121     unsigned int pixelOffset = column * bytesPerPixel;
 122     pixelOffset += ( imageHeight - 1 ) * bufferStride;
 123     pixbuffer[ pixelOffset ] = 0x00;
 124     pixbuffer[ pixelOffset + 1 ] = 0x00;
 125     pixbuffer[ pixelOffset + 2 ] = 0x00;
 126     pixbuffer[ pixelOffset + 3 ] = 0xFF;
 127   }
 128
 129   // Add right child region
 130   for ( unsigned int row = requiredChildRegion.y; row < imageHeight - requiredChildRegion.w; ++row )
 131   {
 132     unsigned int pixelOffset = row * bufferStride + ( imageWidth - 1 ) * bytesPerPixel;
 133     pixbuffer[ pixelOffset ] = 0x00;
 134     pixbuffer[ pixelOffset + 1 ] = 0x00;
 135     pixbuffer[ pixelOffset + 2 ] = 0x00;
 136     pixbuffer[ pixelOffset + 3 ] = 0xFF;
 137   }
 138 }
 139
 140 Integration::ResourcePointer CustomizeNinePatch( TestApplication& application,
 141                                                  unsigned int ninePatchImageWidth,
 142                                                  unsigned int ninePatchImageHeight,
 143                                                  const StretchRanges& stretchRangesX,
 144                                                  const StretchRanges& stretchRangesY,
 145                                                  bool addChildRegion = false,
 146                                                  Vector4 requiredChildRegion = Vector4::ZERO )
 147 {
 148   TestPlatformAbstraction& platform = application.GetPlatform();
 149
 150   Pixel::Format pixelFormat = Pixel::RGBA8888;
 151
 152   tet_infoline("Create Bitmap");
 153   platform.SetClosestImageSize(Vector2( ninePatchImageWidth, ninePatchImageHeight));
 154   Integration::Bitmap* bitmap = CreateBitmap( ninePatchImageWidth, ninePatchImageHeight, 0xFF, pixelFormat );
 155
 156   tet_infoline("Clear border regions");
 157   InitialiseRegionsToZeroAlpha( bitmap, ninePatchImageWidth, ninePatchImageHeight, pixelFormat );
 158
 159   tet_infoline("Add Stretch regions to Bitmap");
 160   AddStretchRegionsToImage( bitmap, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY, pixelFormat );
 161
 162   if( addChildRegion )
 163   {
 164     tet_infoline("Add Child regions to Bitmap");
 165     AddChildRegionsToImage( bitmap, ninePatchImageWidth, ninePatchImageHeight, requiredChildRegion, pixelFormat );
 166   }
 167
 168   tet_infoline("Getting resource");
 169   Integration::ResourcePointer resourcePtr(bitmap);
 170   //platform.SetResourceLoaded( 0, Dali::Integration::ResourceBitmap, resourcePtr );
 171   platform.SetSynchronouslyLoadedResource( resourcePtr);
 172
 173   return resourcePtr;
 174 }
 175
 176 void TestControlRendererRender( ToolkitTestApplication& application,
 177                                 Actor& actor,
 178                                 ControlRenderer& controlRenderer,
 179                                 std::size_t expectedSamplers = 0,
 180                                 ImageDimensions imageDimensions = ImageDimensions(),
 181                                 Integration::ResourcePointer resourcePtr = Integration::ResourcePointer())
 182 {
 183   if( resourcePtr )
 184   {
 185     // set the image size, for test case, this needs to be set before loading started
 186     application.GetPlatform().SetClosestImageSize(  Vector2(imageDimensions.GetWidth(), imageDimensions.GetHeight()) );
 187   }
 188
 189   actor.SetSize( 200.f, 200.f );
 190   Stage::GetCurrent().Add( actor );
 191   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 192   controlRenderer.SetOnStage( actor );
 193
 194   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 195
 196   application.SendNotification();
 197   application.Render();
 198
 199   if( resourcePtr )
 200   {
 201     Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
 202     if(request)
 203     {
 204       application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, resourcePtr );
 205     }
 206   }
 207
 208   application.Render();
 209   application.SendNotification();
 210
 211   if( resourcePtr )
 212   {
 213     DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) ||
 214                      application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceSynchronouslyFunc ));
 215   }
 216
 217   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 218
 219 }
 220
 221 } // namespace
 222
 223
 224 void dali_renderer_factory_startup(void)
 225 {
 226   test_return_value = TET_UNDEF;
 227 }
 228
 229 void dali_renderer_factory_cleanup(void)
 230 {
 231   test_return_value = TET_PASS;
 232 }
 233
 234 int UtcDaliRendererFactoryGet(void)
 235 {
 236   ToolkitTestApplication application;
 237   tet_infoline( "UtcDaliRendererFactory" );
 238
 239   //Register type
 240   TypeInfo type;
 241   type = TypeRegistry::Get().GetTypeInfo( "RendererFactory" );
 242   DALI_TEST_CHECK( type );
 243   BaseHandle handle = type.CreateInstance();
 244   DALI_TEST_CHECK( handle );
 245
 246   RendererFactory factory;
 247   factory = RendererFactory::Get();
 248   DALI_TEST_CHECK( factory );
 249
 250   RendererFactory newFactory = RendererFactory::Get();
 251   DALI_TEST_CHECK( newFactory );
 252
 253   // Check that renderer factory is a singleton
 254   DALI_TEST_CHECK(factory == newFactory);
 255
 256   END_TEST;
 257 }
 258
 259 int UtcDaliRendererFactoryCopyAndAssignment(void)
 260 {
 261   ToolkitTestApplication application;
 262   tet_infoline( "UtcDaliRendererFactoryCopyAndAssignment" );
 263   RendererFactory factory = RendererFactory::Get();
 264
 265   RendererFactory factoryCopy( factory );
 266   DALI_TEST_CHECK(factory == factoryCopy);
 267
 268   RendererFactory emptyFactory;
 269   RendererFactory emptyFactoryCopy( emptyFactory );
 270   DALI_TEST_CHECK(emptyFactory == emptyFactoryCopy);
 271
 272   RendererFactory factoryEquals;
 273   factoryEquals = factory;
 274   DALI_TEST_CHECK(factory == factoryEquals);
 275
 276   RendererFactory emptyFactoryEquals;
 277   emptyFactoryEquals = emptyFactory;
 278   DALI_TEST_CHECK( emptyFactory == emptyFactoryEquals );
 279
 280   //self assignment
 281   factory = factory;
 282   DALI_TEST_CHECK( factory = factoryCopy );
 283
 284   END_TEST;
 285 }
 286
 287 int UtcDaliRendererFactoryGetColorRenderer1(void)
 288 {
 289   ToolkitTestApplication application;
 290   tet_infoline( "UtcDaliRendererFactoryGetColorRenderer1:  Request color renderer with a Property::Map" );
 291
 292   RendererFactory factory = RendererFactory::Get();
 293   DALI_TEST_CHECK( factory );
 294
 295   Property::Map propertyMap;
 296   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 297   propertyMap.Insert("rendererType",  "COLOR");
 298   propertyMap.Insert("mixColor",  testColor);
 299
 300   ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
 301   DALI_TEST_CHECK( controlRenderer );
 302
 303   Actor actor = Actor::New();
 304   TestControlRendererRender( application, actor, controlRenderer );
 305
 306   Vector4 actualValue(Vector4::ZERO);
 307   TestGlAbstraction& gl = application.GetGlAbstraction();
 308   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
 309   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 310
 311   END_TEST;
 312 }
 313
 314 int UtcDaliRendererFactoryGetColorRenderer2(void)
 315 {
 316   ToolkitTestApplication application;
 317   tet_infoline( "UtcDaliRendererFactoryGetColorRenderer2: Request color renderer with a Vector4" );
 318
 319   RendererFactory factory = RendererFactory::Get();
 320   DALI_TEST_CHECK( factory );
 321
 322   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 323   Dali::Property::Map map;
 324   map[ "rendererType" ] = "COLOR";
 325   map[ "mixColor" ] = testColor;
 326   ControlRenderer controlRenderer = factory.CreateControlRenderer( map );
 327   DALI_TEST_CHECK( controlRenderer );
 328
 329   Actor actor = Actor::New();
 330   TestControlRendererRender( application, actor, controlRenderer );
 331
 332   Vector4 actualValue(Vector4::ZERO);
 333   TestGlAbstraction& gl = application.GetGlAbstraction();
 334   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
 335   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 336
 337   controlRenderer.SetOffStage( actor );
 338   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 339
 340   END_TEST;
 341 }
 342
 343 int UtcDaliRendererFactoryGetBorderRenderer1(void)
 344 {
 345   ToolkitTestApplication application;
 346   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer1:  Request border renderer with a Property::Map" );
 347
 348   RendererFactory factory = RendererFactory::Get();
 349   DALI_TEST_CHECK( factory );
 350
 351   Property::Map propertyMap;
 352   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 353   float testSize = 5.f;
 354   propertyMap.Insert("rendererType",  "BORDER");
 355   propertyMap.Insert("borderColor",  testColor);
 356   propertyMap.Insert("borderSize",  testSize);
 357
 358   ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
 359   DALI_TEST_CHECK( controlRenderer );
 360
 361   Actor actor = Actor::New();
 362   actor.SetSize(200.f, 200.f);
 363   Stage::GetCurrent().Add( actor );
 364   controlRenderer.SetSize(Vector2(200.f, 200.f));
 365   controlRenderer.SetOnStage( actor );
 366
 367   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 368   int blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 369   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::ON, TEST_LOCATION );
 370
 371   TestGlAbstraction& gl = application.GetGlAbstraction();
 372
 373   application.SendNotification();
 374   application.Render(0);
 375
 376   Vector4 actualColor(Vector4::ZERO);
 377   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 378   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 379
 380   float actualSize = 0.f;
 381   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 382   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 383
 384   controlRenderer.SetOffStage( actor );
 385   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 386
 387   END_TEST;
 388 }
 389
 390 int UtcDaliRendererFactoryGetBorderRenderer2(void)
 391 {
 392   ToolkitTestApplication application;
 393   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer2:  Request border renderer with a borderSize and a borderColor" );
 394
 395   RendererFactory factory = RendererFactory::Get();
 396   DALI_TEST_CHECK( factory );
 397
 398   Vector4 testColor( 1.f, 0.5f, 0.3f, 1.f );
 399   float testSize = 5.f;
 400
 401   Dali::Property::Map propertyMap;
 402   propertyMap[ "rendererType" ] = "BORDER";
 403   propertyMap[ "borderColor"  ] = testColor;
 404   propertyMap[ "borderSize"   ] = testSize;
 405   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 406   DALI_TEST_CHECK( controlRenderer );
 407
 408   Actor actor = Actor::New();
 409   actor.SetSize(200.f, 200.f);
 410   Stage::GetCurrent().Add( actor );
 411   controlRenderer.SetSize(Vector2(200.f, 200.f));
 412   controlRenderer.SetOnStage( actor );
 413
 414   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 415
 416   TestGlAbstraction& gl = application.GetGlAbstraction();
 417
 418   application.SendNotification();
 419   application.Render(0);
 420
 421   int blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 422   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::AUTO, TEST_LOCATION );
 423
 424   Vector4 actualColor(Vector4::ZERO);
 425   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 426   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 427
 428   float actualSize = 0.f;
 429   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 430   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 431
 432   controlRenderer.SetOffStage( actor );
 433
 434   // enable the anti-aliasing
 435   Dali::Property::Map map;
 436   map[ "rendererType" ] = "BORDER";
 437   map[ "borderColor"  ] = testColor;
 438   map[ "borderSize"   ] = testSize;
 439   map[ "antiAliasing"   ] = true;
 440   controlRenderer = factory.CreateControlRenderer( map );
 441   controlRenderer.SetOnStage( actor );
 442
 443   application.SendNotification();
 444   application.Render(0);
 445   blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 446   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::ON, TEST_LOCATION );
 447
 448   END_TEST;
 449 }
 450
 451 int UtcDaliRendererFactoryGetLinearGradientRenderer(void)
 452 {
 453   ToolkitTestApplication application;
 454   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 455
 456   RendererFactory factory = RendererFactory::Get();
 457   DALI_TEST_CHECK( factory );
 458
 459   Property::Map propertyMap;
 460   propertyMap.Insert("rendererType",  "GRADIENT");
 461
 462   Vector2 start(-1.f, -1.f);
 463   Vector2 end(1.f, 1.f);
 464   propertyMap.Insert("startPosition", start);
 465   propertyMap.Insert("endPosition", end);
 466   propertyMap.Insert("spreadMethod", "REPEAT");
 467
 468   Property::Array stopOffsets;
 469   stopOffsets.PushBack( 0.2f );
 470   stopOffsets.PushBack( 0.8f );
 471   propertyMap.Insert("stopOffset", stopOffsets);
 472
 473   Property::Array stopColors;
 474   stopColors.PushBack( Color::RED );
 475   stopColors.PushBack( Color::GREEN );
 476   propertyMap.Insert("stopColor", stopColors);
 477
 478   ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
 479   DALI_TEST_CHECK( controlRenderer );
 480
 481   // A lookup texture is generated and pass to shader as sampler
 482   Actor actor = Actor::New();
 483   TestControlRendererRender( application, actor, controlRenderer, 1u );
 484
 485   controlRenderer.SetOffStage( actor );
 486   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 487
 488   END_TEST;
 489 }
 490
 491 int UtcDaliRendererFactoryGetRadialGradientRenderer(void)
 492 {
 493   ToolkitTestApplication application;
 494   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 495
 496   RendererFactory factory = RendererFactory::Get();
 497   DALI_TEST_CHECK( factory );
 498
 499   Property::Map propertyMap;
 500   propertyMap.Insert("rendererType",  "GRADIENT");
 501
 502   Vector2 center(100.f, 100.f);
 503   float radius = 100.f;
 504   propertyMap.Insert("units",  "USER_SPACE");
 505   propertyMap.Insert("center",  center);
 506   propertyMap.Insert("radius",  radius);
 507
 508   Property::Array stopOffsets;
 509   stopOffsets.PushBack( 0.0f );
 510   stopOffsets.PushBack( 1.f );
 511   propertyMap.Insert("stopOffset",   stopOffsets);
 512
 513   Property::Array stopColors;
 514   stopColors.PushBack( Color::RED );
 515   stopColors.PushBack( Color::GREEN );
 516   propertyMap.Insert("stopColor",   stopColors);
 517
 518   ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
 519   DALI_TEST_CHECK( controlRenderer );
 520
 521   // A lookup texture is generated and pass to shader as sampler
 522   Actor actor = Actor::New();
 523   TestControlRendererRender( application, actor, controlRenderer, 1u );
 524
 525   Matrix3 alignMatrix( radius, 0.f, 0.f, 0.f, radius, 0.f, center.x, center.y, 1.f );
 526   alignMatrix.Invert();
 527
 528   Matrix3 actualValue( Matrix3::IDENTITY );
 529   TestGlAbstraction& gl = application.GetGlAbstraction();
 530   DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uAlignmentMatrix", actualValue ) );
 531   DALI_TEST_EQUALS( actualValue, alignMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 532
 533   END_TEST;
 534 }
 535
 536 int UtcDaliRendererFactoryDefaultOffsetsGradientRenderer(void)
 537 {
 538   ToolkitTestApplication application;
 539   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 540
 541   RendererFactory factory = RendererFactory::Get();
 542   DALI_TEST_CHECK( factory );
 543
 544   Property::Map propertyMap;
 545   propertyMap.Insert("rendererType",  "GRADIENT");
 546
 547   Vector2 start(-1.f, -1.f);
 548   Vector2 end(1.f, 1.f);
 549   propertyMap.Insert("startPosition", start);
 550   propertyMap.Insert("endPosition", end);
 551   propertyMap.Insert("spreadMethod", "REPEAT");
 552
 553   Property::Array stopColors;
 554   stopColors.PushBack( Color::RED );
 555   stopColors.PushBack( Color::GREEN );
 556   propertyMap.Insert("stopColor", stopColors);
 557
 558   ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
 559   DALI_TEST_CHECK( controlRenderer );
 560
 561   // A lookup texture is generated and pass to shader as sampler
 562   Actor actor = Actor::New();
 563   TestControlRendererRender( application, actor, controlRenderer, 1u );
 564
 565   controlRenderer.SetOffStage( actor );
 566   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 567
 568   END_TEST;
 569 }
 570
 571 int UtcDaliRendererFactoryGetImageRenderer1(void)
 572 {
 573   ToolkitTestApplication application;
 574   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer1: Request image renderer with a Property::Map" );
 575
 576   RendererFactory factory = RendererFactory::Get();
 577   DALI_TEST_CHECK( factory );
 578
 579   Property::Map propertyMap;
 580   propertyMap.Insert( "rendererType",  "IMAGE" );
 581   propertyMap.Insert( "url",  TEST_IMAGE_FILE_NAME );
 582
 583   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 584   DALI_TEST_CHECK( controlRenderer );
 585
 586   Actor actor = Actor::New();
 587   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 588   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 589
 590   const int width=512;
 591   const int height=513;
 592   TestGlAbstraction& gl = application.GetGlAbstraction();
 593   TraceCallStack& textureTrace = gl.GetTextureTrace();
 594   textureTrace.Enable(true);
 595
 596   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 597   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, width, height,width, height );
 598
 599   TestControlRendererRender( application, actor, controlRenderer, 1u,
 600                              ImageDimensions(width, height),
 601                              Integration::ResourcePointer( bitmap ) );
 602
 603   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 604
 605   controlRenderer.SetOffStage( actor );
 606   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 607
 608   END_TEST;
 609 }
 610
 611 int UtcDaliRendererFactoryGetImageRenderer2(void)
 612 {
 613   ToolkitTestApplication application;
 614   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer2: Request image renderer with an image handle" );
 615
 616   RendererFactory factory = RendererFactory::Get();
 617   DALI_TEST_CHECK( factory );
 618
 619   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 620   ControlRenderer controlRenderer = factory.CreateControlRenderer( image );
 621
 622   Actor actor = Actor::New();
 623   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 624   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 625
 626   const int width=512;
 627   const int height=513;
 628
 629   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 630   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, width, height,width, height );
 631
 632   TestGlAbstraction& gl = application.GetGlAbstraction();
 633   TraceCallStack& textureTrace = gl.GetTextureTrace();
 634   textureTrace.Enable(true);
 635
 636   TestControlRendererRender( application, actor, controlRenderer, 1u,
 637                              ImageDimensions(width, height),
 638                              Integration::ResourcePointer(bitmap) );
 639
 640   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 641
 642   END_TEST;
 643 }
 644
 645 int UtcDaliRendererFactoryGetNPatchRenderer1(void)
 646 {
 647   ToolkitTestApplication application;
 648   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer1: Request 9-patch renderer with a Property::Map" );
 649
 650   RendererFactory factory = RendererFactory::Get();
 651   DALI_TEST_CHECK( factory );
 652
 653   const unsigned int ninePatchImageHeight = 18;
 654   const unsigned int ninePatchImageWidth = 28;
 655   StretchRanges stretchRangesX;
 656   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 657   StretchRanges stretchRangesY;
 658   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 659   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 660
 661   Property::Map propertyMap;
 662   propertyMap.Insert( "rendererType",  "IMAGE" );
 663   propertyMap.Insert( "url",  TEST_NPATCH_FILE_NAME );
 664   {
 665     tet_infoline( "whole grid" );
 666     ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 667     DALI_TEST_CHECK( controlRenderer );
 668
 669     Actor actor = Actor::New();
 670
 671     TestGlAbstraction& gl = application.GetGlAbstraction();
 672     TraceCallStack& textureTrace = gl.GetTextureTrace();
 673     textureTrace.Enable(true);
 674
 675     TestControlRendererRender( application, actor, controlRenderer, 1u,
 676                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 677                                ninePatchResource );
 678
 679     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 680   }
 681
 682   propertyMap.Insert( "borderOnly",  true );
 683   {
 684     tet_infoline( "border only" );
 685     ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 686     DALI_TEST_CHECK( controlRenderer );
 687
 688     Actor actor = Actor::New();
 689
 690     TestGlAbstraction& gl = application.GetGlAbstraction();
 691     TraceCallStack& textureTrace = gl.GetTextureTrace();
 692     textureTrace.Enable(true);
 693
 694     TestControlRendererRender( application, actor, controlRenderer, 1u,
 695                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 696                                ninePatchResource );
 697
 698     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 699   }
 700
 701   END_TEST;
 702 }
 703
 704 int UtcDaliRendererFactoryGetNPatchRenderer2(void)
 705 {
 706   ToolkitTestApplication application;
 707   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer2: Request n-patch renderer with a Property::Map" );
 708
 709   RendererFactory factory = RendererFactory::Get();
 710   DALI_TEST_CHECK( factory );
 711
 712   const unsigned int ninePatchImageWidth = 18;
 713   const unsigned int ninePatchImageHeight = 28;
 714   StretchRanges stretchRangesX;
 715   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 716   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 717   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 718   StretchRanges stretchRangesY;
 719   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 720   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 721   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 722   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 723   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 724
 725   Property::Map propertyMap;
 726   propertyMap.Insert( "rendererType",  "IMAGE" );
 727   propertyMap.Insert( "url",  TEST_NPATCH_FILE_NAME );
 728   {
 729     ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 730     DALI_TEST_CHECK( controlRenderer );
 731
 732     Actor actor = Actor::New();
 733     TestGlAbstraction& gl = application.GetGlAbstraction();
 734     TraceCallStack& textureTrace = gl.GetTextureTrace();
 735     textureTrace.Enable(true);
 736
 737     TestControlRendererRender( application, actor, controlRenderer, 1u,
 738                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 739                                ninePatchResource );
 740
 741
 742     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 743
 744     controlRenderer.SetOffStage( actor );
 745     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 746   }
 747
 748   propertyMap.Insert( "borderOnly",  true );
 749   {
 750     tet_infoline( "border only" );
 751     ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 752     DALI_TEST_CHECK( controlRenderer );
 753
 754     TestGlAbstraction& gl = application.GetGlAbstraction();
 755     TraceCallStack& textureTrace = gl.GetTextureTrace();
 756     textureTrace.Enable(true);
 757     Actor actor = Actor::New();
 758     TestControlRendererRender( application, actor, controlRenderer, 1u,
 759                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 760                                ninePatchResource );
 761
 762
 763     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 764
 765     controlRenderer.SetOffStage( actor );
 766     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 767   }
 768
 769   END_TEST;
 770 }
 771
 772 int UtcDaliRendererFactoryGetNPatchRenderer3(void)
 773 {
 774   ToolkitTestApplication application;
 775   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer3: Request 9-patch renderer with an image url" );
 776
 777   RendererFactory factory = RendererFactory::Get();
 778   DALI_TEST_CHECK( factory );
 779
 780   const unsigned int ninePatchImageHeight = 18;
 781   const unsigned int ninePatchImageWidth = 28;
 782   StretchRanges stretchRangesX;
 783   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 784   StretchRanges stretchRangesY;
 785   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 786   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 787
 788   ControlRenderer controlRenderer = factory.CreateControlRenderer( TEST_NPATCH_FILE_NAME, ImageDimensions() );
 789   DALI_TEST_CHECK( controlRenderer );
 790
 791   Actor actor = Actor::New();
 792
 793   TestGlAbstraction& gl = application.GetGlAbstraction();
 794   TraceCallStack& textureTrace = gl.GetTextureTrace();
 795   textureTrace.Enable(true);
 796
 797   TestControlRendererRender( application, actor, controlRenderer, 1u,
 798                              ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 799                              ninePatchResource );
 800
 801   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 802
 803   END_TEST;
 804 }
 805
 806 int UtcDaliRendererFactoryGetNPatchRenderer4(void)
 807 {
 808   ToolkitTestApplication application;
 809   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer4: Request n-patch renderer with an image url" );
 810
 811   RendererFactory factory = RendererFactory::Get();
 812   DALI_TEST_CHECK( factory );
 813
 814   const unsigned int ninePatchImageHeight = 18;
 815   const unsigned int ninePatchImageWidth = 28;
 816   StretchRanges stretchRangesX;
 817   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 818   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 819   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 820   StretchRanges stretchRangesY;
 821   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 822   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 823   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 824   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 825   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 826
 827   ControlRenderer controlRenderer = factory.CreateControlRenderer( TEST_NPATCH_FILE_NAME, ImageDimensions() );
 828   DALI_TEST_CHECK( controlRenderer );
 829
 830   Actor actor = Actor::New();
 831
 832   TestGlAbstraction& gl = application.GetGlAbstraction();
 833   TraceCallStack& textureTrace = gl.GetTextureTrace();
 834   textureTrace.Enable(true);
 835
 836   TestControlRendererRender( application, actor, controlRenderer, 1u,
 837                              ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 838                              ninePatchResource );
 839
 840   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 841
 842   END_TEST;
 843 }
 844
 845 int UtcDaliRendererFactoryGetNPatchRendererN1(void)
 846 {
 847   //This should still load but display an error image
 848
 849   ToolkitTestApplication application;
 850   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid image url" );
 851
 852   RendererFactory factory = RendererFactory::Get();
 853   DALI_TEST_CHECK( factory );
 854
 855   ControlRenderer controlRenderer = factory.CreateControlRenderer( "ERROR.9.jpg", ImageDimensions() );
 856   DALI_TEST_CHECK( controlRenderer );
 857
 858   Actor actor = Actor::New();
 859
 860   //The testkit still has to load a bitmap for the broken renderer image
 861   Integration::Bitmap* bitmap = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD);
 862   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, 100, 100, 100, 100 );
 863
 864   TestGlAbstraction& gl = application.GetGlAbstraction();
 865   TraceCallStack& textureTrace = gl.GetTextureTrace();
 866   textureTrace.Enable(true);
 867
 868   TestControlRendererRender( application, actor, controlRenderer, 1u,
 869                              ImageDimensions(),
 870                              Integration::ResourcePointer(bitmap) );
 871
 872   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 873
 874   END_TEST;
 875 }
 876
 877 int UtcDaliRendererFactoryGetNPatchRendererN2(void)
 878 {
 879   //This should still load but display an error image
 880
 881   ToolkitTestApplication application;
 882   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid Property::Map" );
 883
 884   RendererFactory factory = RendererFactory::Get();
 885   DALI_TEST_CHECK( factory );
 886
 887   Property::Map propertyMap;
 888   propertyMap.Insert( "rendererType",  111 );
 889   propertyMap.Insert( "url",  "ERROR.9.jpg" );
 890
 891   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 892   DALI_TEST_CHECK( controlRenderer );
 893
 894   Actor actor = Actor::New();
 895
 896   //The testkit still has to load a bitmap for the broken renderer image
 897   Integration::Bitmap* bitmap = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD);
 898   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, 100, 100, 100, 100 );
 899
 900   TestGlAbstraction& gl = application.GetGlAbstraction();
 901   TraceCallStack& textureTrace = gl.GetTextureTrace();
 902   textureTrace.Enable(true);
 903
 904   TestControlRendererRender( application, actor, controlRenderer, 1u,
 905                              ImageDimensions(),
 906                              Integration::ResourcePointer(bitmap) );
 907
 908   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 909
 910   END_TEST;
 911 }
 912
 913 int UtcDaliRendererFactoryGetSvgRenderer(void)
 914 {
 915   ToolkitTestApplication application;
 916   tet_infoline( "UtcDaliRendererFactoryGetSvgRenderer: Request svg renderer with a svg url" );
 917
 918   RendererFactory factory = RendererFactory::Get();
 919   ControlRenderer controlRenderer = factory.CreateControlRenderer( TEST_SVG_FILE_NAME, ImageDimensions() );
 920   DALI_TEST_CHECK( controlRenderer );
 921
 922   TestGlAbstraction& gl = application.GetGlAbstraction();
 923   TraceCallStack& textureTrace = gl.GetTextureTrace();
 924   textureTrace.Enable(true);
 925
 926   Actor actor = Actor::New();
 927   actor.SetSize( 200.f, 200.f );
 928   Stage::GetCurrent().Add( actor );
 929   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 930   controlRenderer.SetOnStage( actor );
 931   application.SendNotification();
 932   application.Render();
 933
 934   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 935
 936   EventThreadCallback* eventTrigger = EventThreadCallback::Get();
 937   CallbackBase* callback = eventTrigger->GetCallback();
 938
 939   eventTrigger->WaitingForTrigger( 1 );// waiting until the svg image is rasterized.
 940   CallbackBase::Execute( *callback );
 941
 942   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 943
 944   // waiting for the resource uploading
 945   application.SendNotification();
 946   application.Render();
 947
 948   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 949
 950   END_TEST;
 951 }
 952
 953 //Test if mesh loads correctly when supplied with only the bare minimum requirements, an object file.
 954 int UtcDaliRendererFactoryGetMeshRenderer1(void)
 955 {
 956   ToolkitTestApplication application;
 957   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer1:  Request mesh renderer with a valid object file only" );
 958
 959   RendererFactory factory = RendererFactory::Get();
 960   DALI_TEST_CHECK( factory );
 961
 962   //Set up renderer properties.
 963   Property::Map propertyMap;
 964   propertyMap.Insert( "rendererType",  "MESH" );
 965   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
 966
 967   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 968   DALI_TEST_CHECK( controlRenderer );
 969
 970   Actor actor = Actor::New();
 971   actor.SetSize( 200.f, 200.f );
 972   Stage::GetCurrent().Add( actor );
 973   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
 974   controlRenderer.SetOnStage( actor );
 975
 976   application.SendNotification();
 977   application.Render( 0 );
 978
 979   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 980
 981   //Tell the platform abstraction that the required resources have been loaded.
 982   TestPlatformAbstraction& platform = application.GetPlatform();
 983   platform.SetAllResourceRequestsAsLoaded();
 984
 985   //Render again to upload the now-loaded textures.
 986   application.SendNotification();
 987   application.Render( 0 );
 988
 989   TestGlAbstraction& gl = application.GetGlAbstraction();
 990
 991   Matrix testScaleMatrix;
 992   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
 993   Matrix actualScaleMatrix;
 994
 995   //Test to see if the object has been successfully loaded.
 996   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
 997   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 998
 999   controlRenderer.SetOffStage( actor );
1000   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1001
1002   END_TEST;
1003 }
1004
1005 //Test if mesh loads correctly when supplied with an object file as well as a blank material file and images directory.
1006 int UtcDaliRendererFactoryGetMeshRenderer2(void)
1007 {
1008   ToolkitTestApplication application;
1009   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer2:  Request mesh renderer with blank material file and images directory" );
1010
1011   RendererFactory factory = RendererFactory::Get();
1012   DALI_TEST_CHECK( factory );
1013
1014   //Set up renderer properties.
1015   Property::Map propertyMap;
1016   propertyMap.Insert( "rendererType",  "MESH" );
1017   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1018   propertyMap.Insert( "materialUrl", "" );
1019   propertyMap.Insert( "texturesPath", "" );
1020
1021   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1022   DALI_TEST_CHECK( controlRenderer );
1023
1024   //Add renderer to an actor on stage.
1025   Actor actor = Actor::New();
1026   actor.SetSize( 200.f, 200.f );
1027   Stage::GetCurrent().Add( actor );
1028   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1029   controlRenderer.SetOnStage( actor );
1030
1031   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1032
1033   //Attempt to render to queue resource load requests.
1034   application.SendNotification();
1035   application.Render( 0 );
1036
1037   //Tell the platform abstraction that the required resources have been loaded.
1038   TestPlatformAbstraction& platform = application.GetPlatform();
1039   platform.SetAllResourceRequestsAsLoaded();
1040
1041   //Render again to upload the now-loaded textures.
1042   application.SendNotification();
1043   application.Render( 0 );
1044
1045   TestGlAbstraction& gl = application.GetGlAbstraction();
1046
1047   Matrix testScaleMatrix;
1048   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1049   Matrix actualScaleMatrix;
1050
1051   //Test to see if the object has been successfully loaded.
1052   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1053   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1054
1055   controlRenderer.SetOffStage( actor );
1056   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1057
1058   END_TEST;
1059 }
1060
1061 //Test if mesh loads correctly when supplied with all parameters, an object file, a material file and a directory location.
1062 int UtcDaliRendererFactoryGetMeshRenderer3(void)
1063 {
1064   ToolkitTestApplication application;
1065   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer3:  Request mesh renderer with all parameters correct" );
1066
1067   RendererFactory factory = RendererFactory::Get();
1068   DALI_TEST_CHECK( factory );
1069
1070   //Set up renderer properties.
1071   Property::Map propertyMap;
1072   propertyMap.Insert( "rendererType",  "MESH" );
1073   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1074   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1075   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1076
1077   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1078   DALI_TEST_CHECK( controlRenderer );
1079
1080   //Add renderer to an actor on stage.
1081   Actor actor = Actor::New();
1082   actor.SetSize( 200.f, 200.f );
1083   Stage::GetCurrent().Add( actor );
1084   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1085   controlRenderer.SetOnStage( actor );
1086
1087   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1088
1089   //Attempt to render to queue resource load requests.
1090   application.SendNotification();
1091   application.Render( 0 );
1092
1093   //Tell the platform abstraction that the required resources have been loaded.
1094   TestPlatformAbstraction& platform = application.GetPlatform();
1095   platform.SetAllResourceRequestsAsLoaded();
1096
1097   //Render again to upload the now-loaded textures.
1098   application.SendNotification();
1099   application.Render( 0 );
1100
1101   TestGlAbstraction& gl = application.GetGlAbstraction();
1102
1103   Matrix testScaleMatrix;
1104   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1105   Matrix actualScaleMatrix;
1106
1107   //Test to see if the object has been successfully loaded.
1108   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1109   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1110
1111   controlRenderer.SetOffStage( actor );
1112   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1113
1114   END_TEST;
1115 }
1116
1117 //Test if mesh renderer can load a correctly supplied mesh without a normal map or gloss map in the material file.
1118 int UtcDaliRendererFactoryGetMeshRenderer4(void)
1119 {
1120   ToolkitTestApplication application;
1121   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer4:  Request mesh renderer with diffuse texture but not normal or gloss." );
1122
1123   RendererFactory factory = RendererFactory::Get();
1124   DALI_TEST_CHECK( factory );
1125
1126   //Set up renderer properties.
1127   Property::Map propertyMap;
1128   propertyMap.Insert( "rendererType",  "MESH" );
1129   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1130   propertyMap.Insert( "materialUrl", TEST_SIMPLE_MTL_FILE_NAME );
1131   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1132
1133   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1134   DALI_TEST_CHECK( controlRenderer );
1135
1136   //Add renderer to an actor on stage.
1137   Actor actor = Actor::New();
1138   actor.SetSize( 200.f, 200.f );
1139   Stage::GetCurrent().Add( actor );
1140   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1141   controlRenderer.SetOnStage( actor );
1142
1143   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1144
1145   //Attempt to render to queue resource load requests.
1146   application.SendNotification();
1147   application.Render( 0 );
1148
1149   //Tell the platform abstraction that the required resources have been loaded.
1150   TestPlatformAbstraction& platform = application.GetPlatform();
1151   platform.SetAllResourceRequestsAsLoaded();
1152
1153   //Render again to upload the now-loaded textures.
1154   application.SendNotification();
1155   application.Render( 0 );
1156
1157   TestGlAbstraction& gl = application.GetGlAbstraction();
1158
1159   Matrix testScaleMatrix;
1160   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1161   Matrix actualScaleMatrix;
1162
1163   //Test to see if the object has been successfully loaded.
1164   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1165   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1166
1167   controlRenderer.SetOffStage( actor );
1168   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1169
1170   END_TEST;
1171 }
1172
1173 //Test if mesh renderer loads correctly when supplied an object file without face normals or texture points.
1174 //Note that this notably tests object loader functionality.
1175 int UtcDaliRendererFactoryGetMeshRenderer5(void)
1176 {
1177   ToolkitTestApplication application;
1178   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer5:  Request mesh renderer with normal-less object file." );
1179
1180   RendererFactory factory = RendererFactory::Get();
1181   DALI_TEST_CHECK( factory );
1182
1183   //Set up renderer properties.
1184   Property::Map propertyMap;
1185   propertyMap.Insert( "rendererType", "MESH" );
1186   propertyMap.Insert( "objectUrl", TEST_SIMPLE_OBJ_FILE_NAME );
1187   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1188   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1189
1190   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1191   DALI_TEST_CHECK( controlRenderer );
1192
1193   //Add renderer to an actor on stage.
1194   Actor actor = Actor::New();
1195   actor.SetSize( 200.f, 200.f );
1196   Stage::GetCurrent().Add( actor );
1197   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1198   controlRenderer.SetOnStage( actor );
1199
1200   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1201
1202   //Attempt to render to queue resource load requests.
1203   application.SendNotification();
1204   application.Render( 0 );
1205
1206   //Tell the platform abstraction that the required resources have been loaded.
1207   TestPlatformAbstraction& platform = application.GetPlatform();
1208   platform.SetAllResourceRequestsAsLoaded();
1209
1210   //Render again to upload the now-loaded textures.
1211   application.SendNotification();
1212   application.Render( 0 );
1213
1214   TestGlAbstraction& gl = application.GetGlAbstraction();
1215
1216   Matrix testScaleMatrix;
1217   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1218   Matrix actualScaleMatrix;
1219
1220   //Test to see if the object has been successfully loaded.
1221   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1222   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1223
1224   controlRenderer.SetOffStage( actor );
1225   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1226
1227   END_TEST;
1228 }
1229
1230 //Test if mesh renderer handles the case of lacking an object file.
1231 int UtcDaliRendererFactoryGetMeshRendererN1(void)
1232 {
1233   ToolkitTestApplication application;
1234   tet_infoline( "UtcDaliRendererFactoryGetMeshRendererN1:  Request mesh renderer without object file" );
1235
1236   RendererFactory factory = RendererFactory::Get();
1237   DALI_TEST_CHECK( factory );
1238
1239   //Set up renderer properties.
1240   Property::Map propertyMap;
1241   propertyMap.Insert( "rendererType",  "MESH" );
1242   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1243   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1244
1245   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1246   DALI_TEST_CHECK( controlRenderer );
1247
1248   //Add renderer to an actor on stage.
1249   Actor actor = Actor::New();
1250   actor.SetSize( 200.f, 200.f );
1251   Stage::GetCurrent().Add( actor );
1252   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1253   controlRenderer.SetOnStage( actor );
1254
1255   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1256
1257   //Attempt to render to queue resource load requests.
1258   application.SendNotification();
1259   application.Render( 0 );
1260
1261   //Tell the platform abstraction that the required resources have been loaded.
1262   TestPlatformAbstraction& platform = application.GetPlatform();
1263   platform.SetAllResourceRequestsAsLoaded();
1264
1265   //Render again to upload the now-loaded textures.
1266   application.SendNotification();
1267   application.Render( 0 );
1268
1269   TestGlAbstraction& gl = application.GetGlAbstraction();
1270
1271   //Test to see if the object has not been loaded, as expected.
1272   Matrix scaleMatrix;
1273   DALI_TEST_CHECK( ! gl.GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1274
1275   controlRenderer.SetOffStage( actor );
1276   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1277
1278   END_TEST;
1279 }
1280
1281 //Test if mesh renderer handles the case of being passed invalid material and images urls.
1282 int UtcDaliRendererFactoryGetMeshRendererN2(void)
1283 {
1284   ToolkitTestApplication application;
1285   tet_infoline( "UtcDaliRendererFactoryGetMeshRendererN2:  Request mesh renderer with invalid material and images urls" );
1286
1287   RendererFactory factory = RendererFactory::Get();
1288   DALI_TEST_CHECK( factory );
1289
1290   //Set up renderer properties.
1291   Property::Map propertyMap;
1292   propertyMap.Insert( "rendererType",  "MESH" );
1293   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1294   propertyMap.Insert( "materialUrl", "invalid" );
1295   propertyMap.Insert( "texturesPath", "also invalid" );
1296
1297   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1298   DALI_TEST_CHECK( controlRenderer );
1299
1300   //Add renderer to an actor on stage.
1301   Actor actor = Actor::New();
1302   actor.SetSize( 200.f, 200.f );
1303   Stage::GetCurrent().Add( actor );
1304   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1305   controlRenderer.SetOnStage( actor );
1306
1307   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1308
1309   //Attempt to render to queue resource load requests.
1310   application.SendNotification();
1311   application.Render( 0 );
1312
1313   //Tell the platform abstraction that the required resources have been loaded.
1314   TestPlatformAbstraction& platform = application.GetPlatform();
1315   platform.SetAllResourceRequestsAsLoaded();
1316
1317   //Render again to upload the now-loaded textures.
1318   application.SendNotification();
1319   application.Render( 0 );
1320
1321   TestGlAbstraction& gl = application.GetGlAbstraction();
1322
1323   //Test to see if the object has not been loaded, as expected.
1324   Matrix scaleMatrix;
1325   DALI_TEST_CHECK( ! gl.GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1326
1327   controlRenderer.SetOffStage( actor );
1328   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1329
1330   END_TEST;
1331 }
1332
1333 //Test if mesh renderer handles the case of being passed an invalid object url
1334 int UtcDaliRendererFactoryGetMeshRendererN3(void)
1335 {
1336   ToolkitTestApplication application;
1337   tet_infoline( "UtcDaliRendererFactoryGetMeshRendererN3:  Request mesh renderer with invalid object url" );
1338
1339   RendererFactory factory = RendererFactory::Get();
1340   DALI_TEST_CHECK( factory );
1341
1342   //Set up renderer properties.
1343   Property::Map propertyMap;
1344   propertyMap.Insert( "rendererType",  "MESH" );
1345   propertyMap.Insert( "objectUrl", "invalid" );
1346   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1347   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1348
1349   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1350   DALI_TEST_CHECK( controlRenderer );
1351
1352   //Add renderer to an actor on stage.
1353   Actor actor = Actor::New();
1354   actor.SetSize( 200.f, 200.f );
1355   Stage::GetCurrent().Add( actor );
1356   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1357   controlRenderer.SetOnStage( actor );
1358
1359   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1360
1361   //Attempt to render to queue resource load requests.
1362   application.SendNotification();
1363   application.Render( 0 );
1364
1365   //Tell the platform abstraction that the required resources have been loaded.
1366   TestPlatformAbstraction& platform = application.GetPlatform();
1367   platform.SetAllResourceRequestsAsLoaded();
1368
1369   //Render again to upload the now-loaded textures.
1370   application.SendNotification();
1371   application.Render( 0 );
1372
1373   TestGlAbstraction& gl = application.GetGlAbstraction();
1374
1375   //Test to see if the object has not been loaded, as expected.
1376   Matrix scaleMatrix;
1377   DALI_TEST_CHECK( ! gl.GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1378
1379   controlRenderer.SetOffStage( actor );
1380   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1381
1382   END_TEST;
1383 }
1384
1385 //Creates a primitive renderer with the given property map and tests to see if it correctly loads in the given application.
1386 void TestPrimitiveRendererWithProperties( Property::Map& propertyMap, ToolkitTestApplication& application )
1387 {
1388   RendererFactory factory = RendererFactory::Get();
1389   DALI_TEST_CHECK( factory );
1390
1391   //Create a primitive renderer.
1392   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1393   DALI_TEST_CHECK( controlRenderer );
1394
1395   //Create an actor on stage to house the renderer.
1396   Actor actor = Actor::New();
1397   actor.SetSize( 200.f, 200.f );
1398   Stage::GetCurrent().Add( actor );
1399   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1400   controlRenderer.SetOnStage( actor );
1401
1402   //Ensure set on stage.
1403   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1404
1405   //Tell test application to load the renderer.
1406   application.SendNotification();
1407   application.Render(0);
1408
1409   Matrix testScaleMatrix;
1410   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1411   Matrix actualScaleMatrix;
1412
1413   //Test to see if the object has been successfully loaded.
1414   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1415   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1416
1417   //Finish by setting off stage, and ensuring this was successful.
1418   controlRenderer.SetOffStage( actor );
1419   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1420 }
1421
1422 //Test if primitive shape loads correctly when supplied with only the bare minimum requirements, the shape to use.
1423 int UtcDaliRendererFactoryGetPrimitiveRenderer1(void)
1424 {
1425   //Set up test application first, so everything else can be handled.
1426   ToolkitTestApplication application;
1427
1428   tet_infoline( "UtcDaliRendererFactoryGetPrimitiveRenderer1:  Request primitive renderer with a shape only" );
1429
1430   //Set up renderer properties.
1431   Property::Map propertyMap;
1432   propertyMap.Insert( "rendererType", "PRIMITIVE" );
1433   propertyMap.Insert( "shape", "CUBE" );
1434
1435   //Test to see if shape loads correctly.
1436   TestPrimitiveRendererWithProperties( propertyMap, application );
1437
1438   END_TEST;
1439 }
1440
1441 //Test if primitive shape loads correctly when supplied with all possible parameters
1442 int UtcDaliRendererFactoryGetPrimitiveRenderer2(void)
1443 {
1444   //Set up test application first, so everything else can be handled.
1445   ToolkitTestApplication application;
1446
1447   tet_infoline( "UtcDaliRendererFactoryGetPrimitiveRenderer2:  Request primitive renderer with everything" );
1448
1449   //Set up renderer properties.
1450   Property::Map propertyMap;
1451   propertyMap.Insert( "rendererType", "PRIMITIVE" );
1452   propertyMap.Insert( "shape", "CUBE" );
1453   propertyMap.Insert( "shapeColor", Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1454   propertyMap.Insert( "slices", 10 );
1455   propertyMap.Insert( "stacks", 20 );
1456   propertyMap.Insert( "scaleTopRadius", 30.0f );
1457   propertyMap.Insert( "scaleBottomRadius", 40.0f );
1458   propertyMap.Insert( "scaleHeight", 50.0f );
1459   propertyMap.Insert( "scaleRadius", 60.0f );
1460   propertyMap.Insert( "bevelPercentage", 0.7f );
1461
1462   //Test to see if shape loads correctly.
1463   TestPrimitiveRendererWithProperties( propertyMap, application );
1464
1465   END_TEST;
1466 }
1467
1468 //Test if primitive shape loads a sphere correctly.
1469 int UtcDaliRendererFactoryGetPrimitiveRenderer3(void)
1470 {
1471   //Set up test application first, so everything else can be handled.
1472   ToolkitTestApplication application;
1473
1474   tet_infoline( "UtcDaliRendererFactoryGetPrimitiveRenderer3:  Request primitive renderer to display a sphere" );
1475
1476   //Set up renderer properties.
1477   Property::Map propertyMap;
1478   propertyMap.Insert( "rendererType", "PRIMITIVE" );
1479   propertyMap.Insert( "shape", "SPHERE" );
1480   propertyMap.Insert( "shapeColor", Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1481   propertyMap.Insert( "slices", 10 );
1482   propertyMap.Insert( "stacks", 20 );
1483
1484   //Test to see if shape loads correctly.
1485   TestPrimitiveRendererWithProperties( propertyMap, application );
1486
1487   END_TEST;
1488 }
1489
1490 //Test if primitive shape loads a conic section correctly.
1491 int UtcDaliRendererFactoryGetPrimitiveRenderer4(void)
1492 {
1493   //Set up test application first, so everything else can be handled.
1494   ToolkitTestApplication application;
1495
1496   tet_infoline( "UtcDaliRendererFactoryGetPrimitiveRenderer4:  Request primitive renderer to display a conic section" );
1497
1498   //Set up renderer properties.
1499   Property::Map propertyMap;
1500   propertyMap.Insert( "rendererType", "PRIMITIVE" );
1501   propertyMap.Insert( "shape", "CONICAL_FRUSTRUM" );
1502   propertyMap.Insert( "shapeColor", Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1503   propertyMap.Insert( "slices", 10 );
1504   propertyMap.Insert( "scaleTopRadius", 30.0f );
1505   propertyMap.Insert( "scaleBottomRadius", 40.0f );
1506   propertyMap.Insert( "scaleHeight", 50.0f );
1507
1508   //Test to see if shape loads correctly.
1509   TestPrimitiveRendererWithProperties( propertyMap, application );
1510
1511   END_TEST;
1512 }
1513
1514 //Test if primitive shape loads a bevelled cube correctly.
1515 int UtcDaliRendererFactoryGetPrimitiveRenderer5(void)
1516 {
1517   //Set up test application first, so everything else can be handled.
1518   ToolkitTestApplication application;
1519
1520   tet_infoline( "UtcDaliRendererFactoryGetPrimitiveRenderer5:  Request primitive renderer to display a bevelled cube" );
1521
1522   //Set up renderer properties.
1523   Property::Map propertyMap;
1524   propertyMap.Insert( "rendererType", "PRIMITIVE" );
1525   propertyMap.Insert( "shape", "BEVELLED_CUBE" );
1526   propertyMap.Insert( "shapeColor", Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1527   propertyMap.Insert( "bevelPercentage", 0.7f );
1528
1529   //Test to see if shape loads correctly.
1530   TestPrimitiveRendererWithProperties( propertyMap, application );
1531
1532   END_TEST;
1533 }
1534
1535 //Test if primitive shape loads an octahedron correctly.
1536 int UtcDaliRendererFactoryGetPrimitiveRenderer6(void)
1537 {
1538   //Set up test application first, so everything else can be handled.
1539   ToolkitTestApplication application;
1540
1541   tet_infoline( "UtcDaliRendererFactoryGetPrimitiveRenderer6:  Request primitive renderer to display an octahedron" );
1542
1543   //Set up renderer properties.
1544   Property::Map propertyMap;
1545   propertyMap.Insert( "rendererType", "PRIMITIVE" );
1546   propertyMap.Insert( "shape", "OCTAHEDRON" );
1547   propertyMap.Insert( "shapeColor", Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1548
1549   //Test to see if shape loads correctly.
1550   TestPrimitiveRendererWithProperties( propertyMap, application );
1551
1552   END_TEST;
1553 }
1554
1555 //Test if primitive shape loads a cone correctly.
1556 int UtcDaliRendererFactoryGetPrimitiveRenderer7(void)
1557 {
1558   //Set up test application first, so everything else can be handled.
1559   ToolkitTestApplication application;
1560
1561   tet_infoline( "UtcDaliRendererFactoryGetPrimitiveRenderer7:  Request primitive renderer to display a cone" );
1562
1563   //Set up renderer properties.
1564   Property::Map propertyMap;
1565   propertyMap.Insert( "rendererType", "PRIMITIVE" );
1566   propertyMap.Insert( "shape", "CONE" );
1567   propertyMap.Insert( "shapeColor", Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1568   propertyMap.Insert( "slices", 10 );
1569   propertyMap.Insert( "scaleTopRadius", 30.0f );
1570   propertyMap.Insert( "scaleHeight", 50.0f );
1571
1572   //Test to see if shape loads correctly.
1573   TestPrimitiveRendererWithProperties( propertyMap, application );
1574
1575   END_TEST;
1576 }
1577
1578 //Test if primitive shape loads correctly when light position is manually set.
1579 int UtcDaliRendererFactoryGetPrimitiveRenderer8(void)
1580 {
1581   //Set up test application first, so everything else can be handled.
1582   ToolkitTestApplication application;
1583
1584   tet_infoline( "UtcDaliRendererFactoryGetPrimitiveRenderer8:  Request primitive renderer with set light position" );
1585
1586   //Set up renderer properties.
1587   Property::Map propertyMap;
1588   propertyMap.Insert( "rendererType", "PRIMITIVE" );
1589   propertyMap.Insert( "shape", "SPHERE" );
1590   propertyMap.Insert( "shapeColor", Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1591   propertyMap.Insert( "uLightPosition", Vector3( 0.0, 1.0, 2.0 ) );
1592
1593   //Test to see if shape loads correctly.
1594   TestPrimitiveRendererWithProperties( propertyMap, application );
1595
1596   END_TEST;
1597 }
1598
1599 //Test if primitive shape renderer handles the case of not being passed a specific shape to use.
1600 int UtcDaliRendererFactoryGetPrimitiveRendererN1(void)
1601 {
1602   //Set up test application first, so everything else can be handled.
1603   ToolkitTestApplication application;
1604
1605   tet_infoline( "UtcDaliRendererFactoryGetPrimitiveRendererN1:  Request primitive renderer without shape" );
1606
1607   //Set up renderer properties, without supplying shape.
1608   Property::Map propertyMap;
1609   propertyMap.Insert( "rendererType", "PRIMITIVE" );
1610
1611   //Test to see if shape loads regardless of missing input.
1612   TestPrimitiveRendererWithProperties( propertyMap, application );
1613
1614   END_TEST;
1615 }