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

   1 /*
   2  * Copyright (c) 2020 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-timer.h>
  21 #include <toolkit-event-thread-callback.h>
  22 #include <dali-toolkit/dali-toolkit.h>
  23 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  24 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
  25 #include <dali-toolkit/internal/visuals/npatch-loader.h>
  26 #include <dali/devel-api/adaptor-framework/image-loading.h>
  27 #include <dali-toolkit/devel-api/utility/npatch-utilities.h>
  28 #include "dummy-control.h"
  29
  30 #include <dali/integration-api/debug.h>
  31
  32 using namespace Dali;
  33 using namespace Dali::Toolkit;
  34
  35 namespace
  36 {
  37 typedef Toolkit::NPatchUtility::StretchRanges StretchRanges;
  38
  39 const char* TEST_9_PATCH_FILE_NAME =  TEST_RESOURCE_DIR  "/demo-tile-texture-focused.9.png";
  40 const char* TEST_NPATCH_FILE_NAME =  TEST_RESOURCE_DIR  "/heartsframe.9.png";
  41 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
  42 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
  43 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
  44 const char* TEST_SIMPLE_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube-Points-Only.obj";
  45 const char* TEST_SIMPLE_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal-Simple.mtl";
  46 const char* TEST_AUX_IMAGE = TEST_RESOURCE_DIR "/folder_appicon_empty_bg.png";
  47 const char* TEST_IMAGE_FILE_NAME =  TEST_RESOURCE_DIR  "/gallery-small-1.jpg";
  48
  49 // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
  50 const char* TEST_GIF_FILE_NAME = TEST_RESOURCE_DIR "/anim.gif";
  51
  52 // resolution: 34*34, pixel format: RGBA8888
  53 static const char* gImage_34_RGBA = TEST_RESOURCE_DIR "/icon-edit.png";
  54
  55
  56 Property::Map DefaultTransform()
  57 {
  58   Property::Map transformMap;
  59   transformMap
  60     .Add( Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f) )
  61     .Add( Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f) )
  62     .Add( Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::CENTER )
  63     .Add( Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::CENTER )
  64     .Add( Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) )
  65     .Add( Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2( Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE ) );
  66   return transformMap;
  67 }
  68
  69 void TestVisualRender( ToolkitTestApplication& application,
  70                        DummyControl& actor,
  71                        Visual::Base& visual )
  72 {
  73   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
  74   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
  75
  76   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
  77   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
  78
  79   application.GetScene().Add( actor );
  80
  81   application.SendNotification();
  82   application.Render();
  83
  84   application.Render();
  85   application.SendNotification();
  86
  87   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
  88 }
  89
  90 void TestVisualAsynchronousRender( ToolkitTestApplication& application,
  91                                    DummyControl& actor,
  92                                    Visual::Base& visual )
  93 {
  94   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
  95   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
  96
  97   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
  98   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
  99
 100   application.GetScene().Add( actor );
 101
 102   application.SendNotification();
 103   application.Render();
 104
 105   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
 106
 107   application.SendNotification();
 108   application.Render();
 109
 110   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
 111 }
 112
 113 } // namespace
 114
 115
 116 void dali_visual_factory_startup(void)
 117 {
 118   test_return_value = TET_UNDEF;
 119 }
 120
 121 void dali_visual_factory_cleanup(void)
 122 {
 123   test_return_value = TET_PASS;
 124 }
 125
 126 int UtcDaliVisualFactoryGet(void)
 127 {
 128   ToolkitTestApplication application;
 129   tet_infoline( "UtcDaliVisualFactory" );
 130
 131   //Register type
 132   TypeInfo type;
 133   type = TypeRegistry::Get().GetTypeInfo( "VisualFactory" );
 134   DALI_TEST_CHECK( type );
 135   BaseHandle handle = type.CreateInstance();
 136   DALI_TEST_CHECK( handle );
 137
 138   VisualFactory factory;
 139   factory = VisualFactory::Get();
 140   DALI_TEST_CHECK( factory );
 141
 142   VisualFactory newFactory = VisualFactory::Get();
 143   DALI_TEST_CHECK( newFactory );
 144
 145   // Check that visual factory is a singleton
 146   DALI_TEST_CHECK(factory == newFactory);
 147
 148   END_TEST;
 149 }
 150
 151 int UtcDaliVisualFactoryCopyAndAssignment(void)
 152 {
 153   ToolkitTestApplication application;
 154   tet_infoline( "UtcDaliVisualFactoryCopyAndAssignment" );
 155   VisualFactory factory = VisualFactory::Get();
 156
 157   VisualFactory factoryCopy( factory );
 158   DALI_TEST_CHECK(factory == factoryCopy);
 159
 160   VisualFactory emptyFactory;
 161   VisualFactory emptyFactoryCopy( emptyFactory );
 162   DALI_TEST_CHECK(emptyFactory == emptyFactoryCopy);
 163
 164   VisualFactory factoryEquals;
 165   factoryEquals = factory;
 166   DALI_TEST_CHECK(factory == factoryEquals);
 167
 168   VisualFactory emptyFactoryEquals;
 169   emptyFactoryEquals = emptyFactory;
 170   DALI_TEST_CHECK( emptyFactory == emptyFactoryEquals );
 171
 172   //self assignment
 173   factory = factory;
 174   DALI_TEST_CHECK( factory = factoryCopy );
 175
 176   END_TEST;
 177 }
 178
 179 int UtcDaliVisualFactoryGetColorVisual1(void)
 180 {
 181   ToolkitTestApplication application;
 182   tet_infoline( "UtcDaliVisualFactoryGetColorVisual1:  Request color visual with a Property::Map" );
 183
 184   static std::vector<UniformData> customUniforms =
 185   {
 186     UniformData("mixColor", Property::Type::VECTOR3),
 187   };
 188
 189   TestGraphicsController& graphics = application.GetGraphicsController();
 190   graphics.AddCustomUniforms(customUniforms);
 191
 192   VisualFactory factory = VisualFactory::Get();
 193   DALI_TEST_CHECK( factory );
 194
 195   Property::Map propertyMap;
 196   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 197   propertyMap.Insert(Visual::Property::TYPE,  Visual::COLOR);
 198   propertyMap.Insert(ColorVisual::Property::MIX_COLOR,  testColor);
 199
 200   Visual::Base visual = factory.CreateVisual(propertyMap);
 201   DALI_TEST_CHECK( visual );
 202
 203   DummyControl actor = DummyControl::New(true);
 204   TestVisualRender( application, actor, visual );
 205
 206   Vector3 actualValue(Vector4::ZERO);
 207   Vector4 actualColor(Vector4::ZERO);
 208   TestGlAbstraction& gl = application.GetGlAbstraction();
 209   DALI_TEST_CHECK( gl.GetUniformValue<Vector3>( "mixColor", actualValue ) );
 210   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uColor", actualColor ) );
 211   DALI_TEST_EQUALS( actualValue, Vector3(testColor), TEST_LOCATION );
 212   DALI_TEST_EQUALS( actualColor.a, testColor.a, TEST_LOCATION );
 213
 214   END_TEST;
 215 }
 216
 217 int UtcDaliVisualFactoryGetColorVisual2(void)
 218 {
 219   ToolkitTestApplication application;
 220   tet_infoline( "UtcDaliVisualFactoryGetColorVisual2: Request color visual with a Vector4" );
 221
 222   static std::vector<UniformData> customUniforms =
 223   {
 224     UniformData("mixColor", Property::Type::VECTOR3),
 225   };
 226
 227   TestGraphicsController& graphics = application.GetGraphicsController();
 228   graphics.AddCustomUniforms(customUniforms);
 229
 230   VisualFactory factory = VisualFactory::Get();
 231   DALI_TEST_CHECK( factory );
 232
 233   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 234   Dali::Property::Map map;
 235   map[ Toolkit::Visual::Property::TYPE ] = Visual::COLOR;
 236   map[ ColorVisual::Property::MIX_COLOR ] = testColor;
 237   Visual::Base visual = factory.CreateVisual( map );
 238   DALI_TEST_CHECK( visual );
 239
 240   DummyControl actor = DummyControl::New(true);
 241   TestVisualRender( application, actor, visual );
 242
 243   Vector3 actualValue;
 244   Vector4 actualColor;
 245   TestGlAbstraction& gl = application.GetGlAbstraction();
 246   DALI_TEST_CHECK( gl.GetUniformValue<Vector3>( "mixColor", actualValue ) );
 247   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uColor", actualColor ) );
 248   DALI_TEST_EQUALS( actualValue, Vector3(testColor), TEST_LOCATION );
 249   DALI_TEST_EQUALS( actualColor.a, testColor.a, TEST_LOCATION );
 250
 251   application.GetScene().Remove(actor);
 252   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 253
 254   END_TEST;
 255 }
 256
 257 int UtcDaliVisualFactoryGetBorderVisual1(void)
 258 {
 259   ToolkitTestApplication application;
 260   tet_infoline( "UtcDaliVisualFactoryGetBorderVisual1:  Request border visual with a Property::Map" );
 261
 262   static std::vector<UniformData> customUniforms =
 263   {
 264     UniformData("borderColor", Property::Type::VECTOR4),
 265     UniformData("borderSize", Property::Type::FLOAT),
 266   };
 267
 268   TestGraphicsController& graphics = application.GetGraphicsController();
 269   graphics.AddCustomUniforms(customUniforms);
 270
 271   VisualFactory factory = VisualFactory::Get();
 272   DALI_TEST_CHECK( factory );
 273
 274   Property::Map propertyMap;
 275   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 276   float testSize = 5.f;
 277   propertyMap.Insert(Visual::Property::TYPE,  Visual::BORDER);
 278   propertyMap.Insert(BorderVisual::Property::COLOR,  testColor);
 279   propertyMap.Insert(BorderVisual::Property::SIZE,  testSize);
 280
 281   Visual::Base visual = factory.CreateVisual(propertyMap);
 282   DALI_TEST_CHECK( visual );
 283
 284   DummyControl actor = DummyControl::New(true);
 285   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 286   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 287   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 288   application.GetScene().Add( actor );
 289   visual.SetTransformAndSize(DefaultTransform(), Vector2(200.f, 200.f));
 290
 291   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 292   int blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 293   DALI_TEST_EQUALS( static_cast<BlendMode::Type>(blendMode), BlendMode::ON, TEST_LOCATION );
 294
 295   TestGlAbstraction& gl = application.GetGlAbstraction();
 296
 297   application.SendNotification();
 298   application.Render(0);
 299
 300   Vector4 actualColor(Vector4::ZERO);
 301   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 302   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 303
 304   float actualSize = 0.f;
 305   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 306   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 307
 308   actor.Unparent();
 309   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 310
 311   END_TEST;
 312 }
 313
 314 int UtcDaliVisualFactoryGetBorderVisual2(void)
 315 {
 316   ToolkitTestApplication application;
 317   tet_infoline( "UtcDaliVisualFactoryGetBorderVisual2:  Request border visual with a borderSize and a borderColor" );
 318
 319   static std::vector<UniformData> customUniforms =
 320   {
 321     UniformData("borderColor", Property::Type::VECTOR4),
 322     UniformData("borderSize", Property::Type::FLOAT),
 323   };
 324
 325   TestGraphicsController& graphics = application.GetGraphicsController();
 326   graphics.AddCustomUniforms(customUniforms);
 327
 328   VisualFactory factory = VisualFactory::Get();
 329   DALI_TEST_CHECK( factory );
 330
 331   Vector4 testColor( 1.f, 0.5f, 0.3f, 1.f );
 332   float testSize = 5.f;
 333
 334   Dali::Property::Map propertyMap;
 335   propertyMap[ Toolkit::Visual::Property::TYPE ] = Visual::BORDER;
 336   propertyMap[ BorderVisual::Property::COLOR  ] = testColor;
 337   propertyMap[ BorderVisual::Property::SIZE   ] = testSize;
 338   Visual::Base visual = factory.CreateVisual( propertyMap );
 339   DALI_TEST_CHECK( visual );
 340
 341   DummyControl actor = DummyControl::New(true);
 342   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
 343   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
 344   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
 345   application.GetScene().Add( actor );
 346   visual.SetTransformAndSize(DefaultTransform(), Vector2(200.f, 200.f));
 347
 348   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 349
 350   TestGlAbstraction& gl = application.GetGlAbstraction();
 351
 352   application.SendNotification();
 353   application.Render(0);
 354
 355   int blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 356   DALI_TEST_EQUALS( static_cast<BlendMode::Type>(blendMode), BlendMode::AUTO, TEST_LOCATION );
 357
 358   Vector4 actualColor(Vector4::ZERO);
 359   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 360   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 361
 362   float actualSize = 0.f;
 363   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 364   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 365
 366   actor.Unparent();
 367
 368   // enable the anti-aliasing
 369   Dali::Property::Map map;
 370   map[ Toolkit::Visual::Property::TYPE ] = Visual::BORDER;
 371   map[ BorderVisual::Property::COLOR  ] = testColor;
 372   map[ BorderVisual::Property::SIZE   ] = testSize;
 373   map[ BorderVisual::Property::ANTI_ALIASING   ] = true;
 374   visual = factory.CreateVisual( map );
 375
 376   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
 377   application.GetScene().Add( actor );
 378
 379   blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 380   DALI_TEST_EQUALS( static_cast<BlendMode::Type>(blendMode), BlendMode::ON, TEST_LOCATION );
 381
 382   END_TEST;
 383 }
 384
 385 int UtcDaliVisualFactoryGetLinearGradientVisual(void)
 386 {
 387   ToolkitTestApplication application;
 388   tet_infoline("UtcDaliVisualFactoryGetRadialGradientVisual");
 389
 390   static std::vector<UniformData> customUniforms =
 391   {
 392     UniformData("uAlignmentMatrix", Property::Type::MATRIX),
 393   };
 394
 395   TestGraphicsController& graphics = application.GetGraphicsController();
 396   graphics.AddCustomUniforms(customUniforms);
 397
 398   VisualFactory factory = VisualFactory::Get();
 399   DALI_TEST_CHECK( factory );
 400
 401   Property::Map propertyMap;
 402   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 403
 404   Vector2 start(-1.f, -1.f);
 405   Vector2 end(1.f, 1.f);
 406   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
 407   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
 408   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
 409
 410   Property::Array stopOffsets;
 411   stopOffsets.PushBack( 0.2f );
 412   stopOffsets.PushBack( 0.8f );
 413   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
 414
 415   Property::Array stopColors;
 416   stopColors.PushBack( Color::RED );
 417   stopColors.PushBack( Color::GREEN );
 418   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
 419
 420   Visual::Base visual = factory.CreateVisual(propertyMap);
 421   DALI_TEST_CHECK( visual );
 422
 423   // A lookup texture is generated and pass to shader as sampler
 424   DummyControl actor = DummyControl::New(true);
 425   TestVisualRender( application, actor, visual );
 426
 427   END_TEST;
 428 }
 429
 430 int UtcDaliVisualFactoryGetRadialGradientVisual(void)
 431 {
 432   ToolkitTestApplication application;
 433   tet_infoline("UtcDaliVisualFactoryGetRadialGradientVisual");
 434
 435   static std::vector<UniformData> customUniforms =
 436   {
 437     UniformData("uAlignmentMatrix", Property::Type::MATRIX3),
 438   };
 439
 440   TestGraphicsController& graphics = application.GetGraphicsController();
 441   graphics.AddCustomUniforms(customUniforms);
 442
 443   VisualFactory factory = VisualFactory::Get();
 444   DALI_TEST_CHECK( factory );
 445
 446   Property::Map propertyMap;
 447   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 448
 449   Vector2 center(100.f, 100.f);
 450   float radius = 100.f;
 451   propertyMap.Insert(GradientVisual::Property::UNITS,  GradientVisual::Units::USER_SPACE);
 452   propertyMap.Insert(GradientVisual::Property::CENTER,  center);
 453   propertyMap.Insert(GradientVisual::Property::RADIUS,  radius);
 454
 455   Property::Array stopOffsets;
 456   stopOffsets.PushBack( 0.0f );
 457   stopOffsets.PushBack( 1.f );
 458   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET,   stopOffsets);
 459
 460   Property::Array stopColors;
 461   stopColors.PushBack( Color::RED );
 462   stopColors.PushBack( Color::GREEN );
 463   propertyMap.Insert(GradientVisual::Property::STOP_COLOR,   stopColors);
 464
 465   Visual::Base visual = factory.CreateVisual(propertyMap);
 466   DALI_TEST_CHECK( visual );
 467
 468   // A lookup texture is generated and pass to shader as sampler
 469   DummyControl actor = DummyControl::New(true);
 470   TestVisualRender( application, actor, visual );
 471
 472   Matrix3 alignMatrix( radius, 0.f, 0.f, 0.f, radius, 0.f, center.x, center.y, 1.f );
 473   alignMatrix.Invert();
 474
 475   Matrix3 actualValue( Matrix3::IDENTITY );
 476   TestGlAbstraction& gl = application.GetGlAbstraction();
 477   DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uAlignmentMatrix", actualValue ) );
 478   DALI_TEST_EQUALS( actualValue, alignMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 479
 480   END_TEST;
 481 }
 482
 483 int UtcDaliVisualFactoryDefaultOffsetsGradientVisual(void)
 484 {
 485   ToolkitTestApplication application;
 486   tet_infoline("UtcDaliVisualFactoryGetRadialGradientVisual");
 487
 488   VisualFactory factory = VisualFactory::Get();
 489   DALI_TEST_CHECK( factory );
 490
 491   Property::Map propertyMap;
 492   propertyMap.Insert(Visual::Property::TYPE,  Visual::GRADIENT);
 493
 494   Vector2 start(-1.f, -1.f);
 495   Vector2 end(1.f, 1.f);
 496   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
 497   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
 498   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
 499
 500   Property::Array stopColors;
 501   stopColors.PushBack( Color::RED );
 502   stopColors.PushBack( Color::GREEN );
 503   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
 504
 505   Visual::Base visual = factory.CreateVisual(propertyMap);
 506   DALI_TEST_CHECK( visual );
 507
 508   // A lookup texture is generated and pass to shader as sampler
 509   DummyControl actor = DummyControl::New(true);
 510   TestVisualRender( application, actor, visual );
 511
 512   application.GetScene().Remove( actor );
 513   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 514
 515   END_TEST;
 516 }
 517
 518 int UtcDaliVisualFactoryGetNPatchVisualSynchronousLoad1(void)
 519 {
 520   ToolkitTestApplication application;
 521   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisualSynchronousLoad1: Request 9-patch visual with a Property::Map" );
 522
 523   VisualFactory factory = VisualFactory::Get();
 524   DALI_TEST_CHECK( factory );
 525
 526   // Get actual size of test image
 527   ImageDimensions imageSize = Dali::GetClosestImageSize( TEST_9_PATCH_FILE_NAME );
 528
 529   Property::Map propertyMap;
 530   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 531   propertyMap.Insert( ImageVisual::Property::URL, TEST_9_PATCH_FILE_NAME );
 532   propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, true );
 533   {
 534     tet_infoline( "whole grid" );
 535     Visual::Base visual = factory.CreateVisual( propertyMap );
 536     DALI_TEST_CHECK( visual );
 537
 538     TestGlAbstraction& gl = application.GetGlAbstraction();
 539     TraceCallStack& textureTrace = gl.GetTextureTrace();
 540     textureTrace.Enable(true);
 541
 542     DummyControl actor = DummyControl::New(true);
 543     TestVisualRender( application, actor, visual );
 544
 545     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 546
 547     Vector2 naturalSize( 0.0f, 0.0f );
 548     visual.GetNaturalSize( naturalSize );
 549     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
 550   }
 551
 552   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 553   {
 554     tet_infoline( "border only" );
 555     Visual::Base visual = factory.CreateVisual( propertyMap );
 556     DALI_TEST_CHECK( visual );
 557
 558     TestGlAbstraction& gl = application.GetGlAbstraction();
 559     TraceCallStack& textureTrace = gl.GetTextureTrace();
 560     textureTrace.Enable(true);
 561
 562     DummyControl actor = DummyControl::New(true);
 563     TestVisualRender( application, actor, visual );
 564
 565     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 566
 567     Vector2 naturalSize( 0.0f, 0.0f );
 568     visual.GetNaturalSize( naturalSize );
 569     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
 570   }
 571
 572   END_TEST;
 573 }
 574
 575 int UtcDaliVisualFactoryGetNPatchVisualSynchronousLoad2(void)
 576 {
 577   ToolkitTestApplication application;
 578   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisualSynchronousLoad2: Request 9-patch visual with a Property::Map including border" );
 579
 580   VisualFactory factory = VisualFactory::Get();
 581   DALI_TEST_CHECK( factory );
 582
 583   // Get actual size of test image
 584   ImageDimensions imageSize = Dali::GetClosestImageSize( gImage_34_RGBA );
 585
 586   Property::Map propertyMap;
 587   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 588   propertyMap.Insert( ImageVisual::Property::URL, gImage_34_RGBA );
 589   propertyMap.Insert( ImageVisual::Property::BORDER, Rect< int >( 2, 2, 2, 2 ) );
 590   propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, true );
 591   {
 592     tet_infoline( "whole grid" );
 593     Visual::Base visual = factory.CreateVisual( propertyMap );
 594     DALI_TEST_CHECK( visual );
 595
 596     TestGlAbstraction& gl = application.GetGlAbstraction();
 597     TraceCallStack& textureTrace = gl.GetTextureTrace();
 598     textureTrace.Enable(true);
 599
 600     DummyControl actor = DummyControl::New(true);
 601     TestVisualRender( application, actor, visual );
 602
 603     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 604
 605     Vector2 naturalSize( 0.0f, 0.0f );
 606     visual.GetNaturalSize( naturalSize );
 607     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
 608   }
 609
 610   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 611   {
 612     tet_infoline( "border only" );
 613     Visual::Base visual = factory.CreateVisual( propertyMap );
 614     DALI_TEST_CHECK( visual );
 615
 616     TestGlAbstraction& gl = application.GetGlAbstraction();
 617     TraceCallStack& textureTrace = gl.GetTextureTrace();
 618     textureTrace.Enable(true);
 619
 620     DummyControl actor = DummyControl::New(true);
 621     TestVisualRender( application, actor, visual );
 622
 623     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 624
 625     Vector2 naturalSize( 0.0f, 0.0f );
 626     visual.GetNaturalSize( naturalSize );
 627     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
 628   }
 629
 630   propertyMap.Clear();
 631   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 632   propertyMap.Insert( ImageVisual::Property::URL, gImage_34_RGBA );
 633   propertyMap.Insert( ImageVisual::Property::BORDER, Rect< int >( 1, 1, 1, 1 ) );
 634   propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, true );
 635   {
 636     tet_infoline( "whole grid" );
 637     Visual::Base visual = factory.CreateVisual( propertyMap );
 638     DALI_TEST_CHECK( visual );
 639
 640     TestGlAbstraction& gl = application.GetGlAbstraction();
 641     TraceCallStack& textureTrace = gl.GetTextureTrace();
 642     textureTrace.Enable(true);
 643
 644     DummyControl actor = DummyControl::New(true);
 645     TestVisualRender( application, actor, visual );
 646
 647     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 648
 649     Vector2 naturalSize( 0.0f, 0.0f );
 650     visual.GetNaturalSize( naturalSize );
 651     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
 652   }
 653
 654   END_TEST;
 655 }
 656
 657 int UtcDaliVisualFactoryGetNPatchVisual1(void)
 658 {
 659   ToolkitTestApplication application;
 660   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual1: Request 9-patch visual with a Property::Map" );
 661
 662   VisualFactory factory = VisualFactory::Get();
 663   DALI_TEST_CHECK( factory );
 664
 665   // Get actual size of test image
 666   ImageDimensions imageSize = Dali::GetClosestImageSize( TEST_9_PATCH_FILE_NAME );
 667
 668   Property::Map propertyMap;
 669   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 670   propertyMap.Insert( ImageVisual::Property::URL, TEST_9_PATCH_FILE_NAME );
 671   propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, false );
 672   {
 673     tet_infoline( "whole grid" );
 674     Visual::Base visual = factory.CreateVisual( propertyMap );
 675     DALI_TEST_CHECK( visual );
 676
 677     Vector2 naturalSize( 0.0f, 0.0f );
 678     visual.GetNaturalSize( naturalSize );
 679     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
 680
 681     TestGlAbstraction& gl = application.GetGlAbstraction();
 682     TraceCallStack& textureTrace = gl.GetTextureTrace();
 683     textureTrace.Enable(true);
 684
 685     DummyControl actor = DummyControl::New(true);
 686     TestVisualAsynchronousRender( application, actor, visual );
 687
 688     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 689
 690     visual.GetNaturalSize( naturalSize );
 691     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
 692   }
 693
 694   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 695   {
 696     tet_infoline( "border only" );
 697     Visual::Base visual = factory.CreateVisual( propertyMap );
 698     DALI_TEST_CHECK( visual );
 699
 700     TestGlAbstraction& gl = application.GetGlAbstraction();
 701     TraceCallStack& textureTrace = gl.GetTextureTrace();
 702     textureTrace.Enable(true);
 703
 704     DummyControl actor = DummyControl::New(true);
 705     TestVisualRender( application, actor, visual );
 706
 707     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 708
 709     Vector2 naturalSize( 0.0f, 0.0f );
 710     visual.GetNaturalSize( naturalSize );
 711     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
 712   }
 713
 714   END_TEST;
 715 }
 716
 717 int UtcDaliVisualFactoryGetNPatchVisual2(void)
 718 {
 719   ToolkitTestApplication application;
 720   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual2: Request 9-patch visual with a Property::Map including border" );
 721
 722   VisualFactory factory = VisualFactory::Get();
 723   DALI_TEST_CHECK( factory );
 724
 725   // Get actual size of test image
 726   ImageDimensions imageSize = Dali::GetClosestImageSize( gImage_34_RGBA );
 727
 728   Property::Map propertyMap;
 729   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 730   propertyMap.Insert( ImageVisual::Property::URL, gImage_34_RGBA );
 731   propertyMap.Insert( ImageVisual::Property::BORDER, Rect< int >( 2, 2, 2, 2 ) );
 732   {
 733     tet_infoline( "whole grid" );
 734     Visual::Base visual = factory.CreateVisual( propertyMap );
 735     DALI_TEST_CHECK( visual );
 736
 737     TestGlAbstraction& gl = application.GetGlAbstraction();
 738     TraceCallStack& textureTrace = gl.GetTextureTrace();
 739     textureTrace.Enable(true);
 740
 741     DummyControl actor = DummyControl::New(true);
 742     TestVisualAsynchronousRender( application, actor, visual );
 743
 744     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 745
 746     Vector2 naturalSize( 0.0f, 0.0f );
 747     visual.GetNaturalSize( naturalSize );
 748     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
 749   }
 750
 751   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 752   {
 753     tet_infoline( "border only" );
 754     Visual::Base visual = factory.CreateVisual( propertyMap );
 755     DALI_TEST_CHECK( visual );
 756
 757     TestGlAbstraction& gl = application.GetGlAbstraction();
 758     TraceCallStack& textureTrace = gl.GetTextureTrace();
 759     textureTrace.Enable(true);
 760
 761     DummyControl actor = DummyControl::New(true);
 762     TestVisualRender( application, actor, visual );
 763
 764     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 765
 766     Vector2 naturalSize( 0.0f, 0.0f );
 767     visual.GetNaturalSize( naturalSize );
 768     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
 769   }
 770
 771   propertyMap.Clear();
 772   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 773   propertyMap.Insert( ImageVisual::Property::URL, gImage_34_RGBA );
 774   propertyMap.Insert( ImageVisual::Property::BORDER, Rect< int >( 1, 1, 1, 1 ) );
 775   {
 776     tet_infoline( "whole grid" );
 777     Visual::Base visual = factory.CreateVisual( propertyMap );
 778     DALI_TEST_CHECK( visual );
 779
 780     TestGlAbstraction& gl = application.GetGlAbstraction();
 781     TraceCallStack& textureTrace = gl.GetTextureTrace();
 782     textureTrace.Enable(true);
 783
 784     DummyControl actor = DummyControl::New(true);
 785     TestVisualRender( application, actor, visual );
 786
 787     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 788
 789     Vector2 naturalSize( 0.0f, 0.0f );
 790     visual.GetNaturalSize( naturalSize );
 791     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
 792   }
 793
 794   END_TEST;
 795 }
 796
 797 int UtcDaliVisualFactoryGetNPatchVisual3(void)
 798 {
 799   ToolkitTestApplication application;
 800   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual3: Request n-patch visual with a Property::Map" );
 801
 802   VisualFactory factory = VisualFactory::Get();
 803   DALI_TEST_CHECK( factory );
 804
 805   // Get actual size of test image
 806   ImageDimensions imageSize = Dali::GetClosestImageSize( TEST_NPATCH_FILE_NAME );
 807
 808   Property::Map propertyMap;
 809   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 810   propertyMap.Insert( ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME );
 811   {
 812     Visual::Base visual = factory.CreateVisual( propertyMap );
 813     DALI_TEST_CHECK( visual );
 814
 815     TestGlAbstraction& gl = application.GetGlAbstraction();
 816     TraceCallStack& textureTrace = gl.GetTextureTrace();
 817     textureTrace.Enable(true);
 818
 819     DummyControl actor = DummyControl::New(true);
 820     TestVisualAsynchronousRender( application, actor, visual );
 821
 822     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 823
 824     Vector2 naturalSize( 0.0f, 0.0f );
 825     visual.GetNaturalSize( naturalSize );
 826     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
 827   }
 828
 829   propertyMap.Insert( ImageVisual::Property::BORDER_ONLY,  true );
 830   {
 831     tet_infoline( "border only" );
 832     Visual::Base visual = factory.CreateVisual( propertyMap );
 833     DALI_TEST_CHECK( visual );
 834
 835     TestGlAbstraction& gl = application.GetGlAbstraction();
 836     TraceCallStack& textureTrace = gl.GetTextureTrace();
 837     textureTrace.Enable(true);
 838     DummyControl actor = DummyControl::New(true);
 839     TestVisualRender( application, actor, visual );
 840
 841     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 842
 843     Vector2 naturalSize( 0.0f, 0.0f );
 844     visual.GetNaturalSize( naturalSize );
 845     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
 846
 847     application.GetScene().Remove( actor );
 848     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 849   }
 850
 851   END_TEST;
 852 }
 853
 854 int UtcDaliVisualFactoryGetNPatchVisual4(void)
 855 {
 856   ToolkitTestApplication application;
 857   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual4: Request 9-patch visual with an image url" );
 858
 859   // Get actual size of test image
 860   ImageDimensions imageSize = Dali::GetClosestImageSize( TEST_9_PATCH_FILE_NAME );
 861
 862   VisualFactory factory = VisualFactory::Get();
 863   DALI_TEST_CHECK( factory );
 864
 865   Visual::Base visual = factory.CreateVisual( TEST_9_PATCH_FILE_NAME, ImageDimensions() );
 866   DALI_TEST_CHECK( visual );
 867
 868   TestGlAbstraction& gl = application.GetGlAbstraction();
 869   TraceCallStack& textureTrace = gl.GetTextureTrace();
 870   textureTrace.Enable(true);
 871   DummyControl actor = DummyControl::New(true);
 872   TestVisualAsynchronousRender( application, actor, visual );
 873
 874   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 875
 876   Vector2 naturalSize( 0.0f, 0.0f );
 877   visual.GetNaturalSize( naturalSize );
 878   DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
 879
 880   textureTrace.Reset();
 881
 882   END_TEST;
 883 }
 884
 885 int UtcDaliVisualFactoryGetNPatchVisual5(void)
 886 {
 887   ToolkitTestApplication application;
 888   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual5: Request n-patch visual with an image url" );
 889
 890   // Get actual size of test image
 891   ImageDimensions imageSize = Dali::GetClosestImageSize( TEST_NPATCH_FILE_NAME );
 892
 893   VisualFactory factory = VisualFactory::Get();
 894   DALI_TEST_CHECK( factory );
 895
 896   Visual::Base visual = factory.CreateVisual( TEST_NPATCH_FILE_NAME, ImageDimensions() );
 897   DALI_TEST_CHECK( visual );
 898
 899   TestGlAbstraction& gl = application.GetGlAbstraction();
 900   TraceCallStack& textureTrace = gl.GetTextureTrace();
 901   textureTrace.Enable(true);
 902
 903   DummyControl actor = DummyControl::New(true);
 904   TestVisualAsynchronousRender( application, actor, visual );
 905
 906   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 907
 908   Vector2 naturalSize( 0.0f, 0.0f );
 909   visual.GetNaturalSize( naturalSize );
 910   DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
 911
 912   END_TEST;
 913 }
 914
 915 int UtcDaliVisualFactoryGetNPatchVisual6(void)
 916 {
 917   ToolkitTestApplication application;
 918   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual6: Request n-patch visual with a general image" );
 919
 920   VisualFactory factory = VisualFactory::Get();
 921   DALI_TEST_CHECK( factory );
 922
 923   {
 924     // Get actual size of test image
 925     ImageDimensions imageSize = Dali::GetClosestImageSize( gImage_34_RGBA );
 926
 927     Property::Map propertyMap;
 928     propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 929     propertyMap.Insert( ImageVisual::Property::URL, gImage_34_RGBA );
 930
 931     Visual::Base visual = factory.CreateVisual( propertyMap );
 932     DALI_TEST_CHECK( visual );
 933
 934     TestGlAbstraction& gl = application.GetGlAbstraction();
 935     TraceCallStack& textureTrace = gl.GetTextureTrace();
 936     textureTrace.Enable(true);
 937
 938     DummyControl actor = DummyControl::New(true);
 939     TestVisualAsynchronousRender( application, actor, visual );
 940
 941     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 942
 943     Vector2 naturalSize( 0.0f, 0.0f );
 944     visual.GetNaturalSize( naturalSize );
 945     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
 946
 947     application.GetScene().Remove( actor );
 948     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 949   }
 950
 951   {
 952     // Get actual size of test image
 953     ImageDimensions imageSize = Dali::GetClosestImageSize( TEST_IMAGE_FILE_NAME );
 954
 955     Property::Map propertyMap;
 956     propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 957     propertyMap.Insert( ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME );
 958
 959     Visual::Base visual = factory.CreateVisual( propertyMap );
 960     DALI_TEST_CHECK( visual );
 961
 962     TestGlAbstraction& gl = application.GetGlAbstraction();
 963     TraceCallStack& textureTrace = gl.GetTextureTrace();
 964     textureTrace.Enable(true);
 965
 966     DummyControl actor = DummyControl::New(true);
 967     TestVisualAsynchronousRender( application, actor, visual );
 968
 969     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 970
 971     Vector2 naturalSize( 0.0f, 0.0f );
 972     visual.GetNaturalSize( naturalSize );
 973     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth() - 2.0f, imageSize.GetHeight() - 2.0f ), TEST_LOCATION );
 974
 975     application.GetScene().Remove( actor );
 976     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 977   }
 978
 979   END_TEST;
 980 }
 981
 982 int UtcDaliVisualFactoryGetNPatchVisual7(void)
 983 {
 984   ToolkitTestApplication application;
 985   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual7: Add 9-patch visual on stage and instantly remove it." );
 986
 987   VisualFactory factory = VisualFactory::Get();
 988   DALI_TEST_CHECK( factory );
 989
 990   // Get actual size of test image
 991   ImageDimensions imageSize = Dali::GetClosestImageSize( TEST_9_PATCH_FILE_NAME );
 992
 993   Property::Map propertyMap;
 994   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
 995   propertyMap.Insert( ImageVisual::Property::URL, TEST_9_PATCH_FILE_NAME );
 996   propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, false );
 997   {
 998     Visual::Base visual = factory.CreateVisual( propertyMap );
 999     DALI_TEST_CHECK( visual );
1000
1001     Vector2 naturalSize( 0.0f, 0.0f );
1002     visual.GetNaturalSize( naturalSize );
1003     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
1004
1005     TestGlAbstraction& gl = application.GetGlAbstraction();
1006     TraceCallStack& textureTrace = gl.GetTextureTrace();
1007     textureTrace.Enable(true);
1008
1009     DummyControl actor = DummyControl::New(true);
1010
1011     DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1012     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1013
1014     actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1015     DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1016
1017     application.GetScene().Add( actor );
1018     actor.Unparent();
1019
1020     application.SendNotification();
1021     application.Render();
1022
1023     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger(1 ), true, TEST_LOCATION );
1024
1025     application.SendNotification();
1026     application.Render();
1027
1028     DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1029   }
1030
1031   END_TEST;
1032 }
1033
1034 int UtcDaliVisualFactoryGetNPatchVisual8(void)
1035 {
1036   ToolkitTestApplication application;
1037   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisual8: Add 9-patch visual on stage, instantly remove it and add new 9-patch visual with same propertyMap" );
1038
1039   VisualFactory factory = VisualFactory::Get();
1040   DALI_TEST_CHECK( factory );
1041
1042   // Get actual size of test image
1043   ImageDimensions imageSize = Dali::GetClosestImageSize( TEST_9_PATCH_FILE_NAME );
1044
1045   Property::Map propertyMap;
1046   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
1047   propertyMap.Insert( ImageVisual::Property::URL, TEST_9_PATCH_FILE_NAME );
1048   propertyMap.Insert( ImageVisual::Property::SYNCHRONOUS_LOADING, false );
1049   {
1050     Visual::Base visual = factory.CreateVisual( propertyMap );
1051     DALI_TEST_CHECK( visual );
1052
1053     Vector2 naturalSize( 0.0f, 0.0f );
1054     visual.GetNaturalSize( naturalSize );
1055     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
1056
1057     TestGlAbstraction& gl = application.GetGlAbstraction();
1058     TraceCallStack& textureTrace = gl.GetTextureTrace();
1059     textureTrace.Enable(true);
1060
1061     DummyControl actor = DummyControl::New(true);
1062
1063     DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1064     dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1065
1066     actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1067     DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1068
1069     application.GetScene().Add( actor );
1070     actor.Unparent();
1071
1072     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION );
1073
1074     application.SendNotification();
1075     application.Render();
1076
1077     visual = factory.CreateVisual( propertyMap );
1078     DALI_TEST_CHECK( visual );
1079
1080     visual.GetNaturalSize( naturalSize );
1081     DALI_TEST_EQUALS( naturalSize, Vector2( imageSize.GetWidth(), imageSize.GetHeight() ), TEST_LOCATION );
1082
1083     actor = DummyControl::New(true);
1084
1085     DummyControlImpl& dummyImpl2 = static_cast<DummyControlImpl&>(actor.GetImplementation());
1086     dummyImpl2.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1087
1088     actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1089     DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1090
1091     application.GetScene().Add( actor );
1092
1093     DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger(1 ), true, TEST_LOCATION );
1094
1095     application.SendNotification();
1096     application.Render();
1097
1098     Renderer renderer = actor.GetRendererAt( 0 );
1099     auto textures = renderer.GetTextures();
1100
1101     DALI_TEST_EQUALS( textures.GetTextureCount(), 1, TEST_LOCATION );
1102   }
1103
1104   END_TEST;
1105 }
1106
1107 int UtcDaliNPatchVisualAuxiliaryImage01(void)
1108 {
1109   ToolkitTestApplication application;
1110   tet_infoline( "NPatchVisual with aux image" );
1111
1112   VisualFactory factory = VisualFactory::Get();
1113   Property::Map properties;
1114   Property::Map shader;
1115
1116   Property::Map transformMap;
1117   transformMap["size"] = Vector2( 0.5f, 0.5f ) ;
1118   transformMap["offset"] = Vector2( 20.0f, 0.0f ) ;
1119   transformMap["offsetPolicy"] = Vector2( Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE );
1120   transformMap["anchorPoint"] = Align::CENTER;
1121   transformMap["origin"] = Align::CENTER;
1122   properties[Visual::Property::TRANSFORM] = transformMap;
1123
1124   properties[Visual::Property::TYPE] = Visual::IMAGE;
1125   properties[Visual::Property::MIX_COLOR] = Color::BLUE;
1126   properties[Visual::Property::SHADER]=shader;
1127   properties[ImageVisual::Property::URL] = TEST_9_PATCH_FILE_NAME;
1128   properties[DevelImageVisual::Property::AUXILIARY_IMAGE] = TEST_AUX_IMAGE;
1129   properties[DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA] = 0.9f;
1130
1131   Visual::Base visual = factory.CreateVisual( properties );
1132
1133   // trigger creation through setting on stage
1134   DummyControl dummy = DummyControl::New(true);
1135   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
1136   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1137   dummyImpl.SetLayout( DummyControl::Property::TEST_VISUAL, transformMap );
1138   dummy.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
1139   dummy.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
1140   application.GetScene().Add(dummy);
1141
1142   application.SendNotification();
1143   application.Render();
1144
1145   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 2 ), true, TEST_LOCATION );
1146
1147   application.SendNotification();
1148   application.Render();
1149
1150   Renderer renderer = dummy.GetRendererAt( 0 );
1151   auto textures = renderer.GetTextures();
1152   DALI_TEST_EQUALS( textures.GetTextureCount(), 2, TEST_LOCATION );
1153
1154   END_TEST;
1155 }
1156
1157 int UtcDaliNPatchVisualAuxiliaryImage02(void)
1158 {
1159   ToolkitTestApplication application;
1160   tet_infoline( "Multiple NPatchVisual with aux image coincidentally" );
1161
1162   const Property::Value NPATCH_TEST{
1163     {ImageVisual::Property::URL, TEST_9_PATCH_FILE_NAME},
1164     {DevelImageVisual::Property::AUXILIARY_IMAGE, TEST_AUX_IMAGE}};
1165
1166   ImageView imageView1 = ImageView::New();
1167   imageView1[ImageView::Property::IMAGE] = NPATCH_TEST;
1168   application.GetScene().Add( imageView1 );
1169
1170   ImageView imageView2 = ImageView::New();
1171   imageView2[ImageView::Property::IMAGE] = NPATCH_TEST;
1172   application.GetScene().Add( imageView2 );
1173
1174   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 3 ), true, TEST_LOCATION );
1175
1176   application.SendNotification();
1177   application.Render();
1178
1179   Renderer renderer1 = imageView1.GetRendererAt( 0 );
1180   auto textureSet1 = renderer1.GetTextures();
1181
1182   Renderer renderer2 = imageView2.GetRendererAt( 0 );
1183   auto textureSet2 = renderer2.GetTextures();
1184   DALI_TEST_EQUALS( textureSet1 != textureSet2, true, TEST_LOCATION );
1185
1186   END_TEST;
1187 }
1188
1189
1190 int UtcDaliVisualFactoryGetNPatchVisualN1(void)
1191 {
1192   //This should still load but display an error image
1193
1194   ToolkitTestApplication application;
1195   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisualN: Request n-patch visual with an invalid image url" );
1196
1197   VisualFactory factory = VisualFactory::Get();
1198   DALI_TEST_CHECK( factory );
1199
1200   Visual::Base visual = factory.CreateVisual( "ERROR.9.jpg", ImageDimensions() );
1201   DALI_TEST_CHECK( visual );
1202
1203   TestGlAbstraction& gl = application.GetGlAbstraction();
1204   TraceCallStack& textureTrace = gl.GetTextureTrace();
1205   textureTrace.Enable(true);
1206
1207   DummyControl actor = DummyControl::New(true);
1208   TestVisualAsynchronousRender( application, actor, visual );
1209
1210   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1211
1212   END_TEST;
1213 }
1214
1215 int UtcDaliVisualFactoryGetNPatchVisualN2(void)
1216 {
1217   //This should still load but display an error image
1218
1219   ToolkitTestApplication application;
1220   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisualN: Request n-patch visual with an invalid URL" );
1221
1222   VisualFactory factory = VisualFactory::Get();
1223   DALI_TEST_CHECK( factory );
1224
1225   Property::Map propertyMap;
1226   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
1227   propertyMap.Insert( ImageVisual::Property::URL,  "ERROR.9.jpg" );
1228
1229   Visual::Base visual = factory.CreateVisual( propertyMap );
1230   DALI_TEST_CHECK( visual );
1231
1232   TestGlAbstraction& gl = application.GetGlAbstraction();
1233   TraceCallStack& textureTrace = gl.GetTextureTrace();
1234   textureTrace.Enable(true);
1235   TraceCallStack& drawTrace = gl.GetDrawTrace();
1236   drawTrace.Enable(true);
1237
1238   DummyControl actor = DummyControl::New(true);
1239   TestVisualAsynchronousRender( application, actor, visual );
1240
1241   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1242
1243   END_TEST;
1244 }
1245
1246 int UtcDaliVisualFactoryGetNPatchVisualN3(void)
1247 {
1248   // Passing in an invalid visual type so we should not get a visual
1249
1250   ToolkitTestApplication application;
1251   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisualN: Request n-patch visual with an invalid visual type" );
1252
1253   VisualFactory factory = VisualFactory::Get();
1254   DALI_TEST_CHECK( factory );
1255
1256   Property::Map propertyMap;
1257   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  111 );
1258   propertyMap.Insert( ImageVisual::Property::URL,  "ERROR.9.jpg" );
1259
1260   Visual::Base visual = factory.CreateVisual( propertyMap );
1261   DALI_TEST_CHECK( !visual );
1262
1263   END_TEST;
1264 }
1265
1266 int UtcDaliVisualFactoryGetSvgVisual(void)
1267 {
1268   ToolkitTestApplication application;
1269   tet_infoline( "UtcDaliVisualFactoryGetSvgVisual: Request svg visual with a svg url" );
1270
1271   VisualFactory factory = VisualFactory::Get();
1272   Visual::Base visual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
1273   DALI_TEST_CHECK( visual );
1274
1275   TestGlAbstraction& gl = application.GetGlAbstraction();
1276   TraceCallStack& textureTrace = gl.GetTextureTrace();
1277   textureTrace.Enable(true);
1278
1279   DummyControl actor = DummyControl::New(true);
1280   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1281   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1282   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1283   application.GetScene().Add( actor );
1284   visual.SetTransformAndSize(DefaultTransform(), Vector2(200.f, 200.f) );
1285
1286   // Either application.SendNotification() or the trigger can now complete the task.
1287   application.SendNotification();
1288   application.Render();
1289   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1290
1291   // renderer is added to actor
1292   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1293
1294   // waiting for the resource uploading
1295   application.SendNotification();
1296   application.Render();
1297
1298   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1299
1300   END_TEST;
1301 }
1302
1303 int UtcDaliVisualFactoryGetSvgVisualLarge(void)
1304 {
1305   ToolkitTestApplication application;
1306   tet_infoline( "UtcDaliVisualFactoryGetSvgVisual: Request svg visual with a svg url" );
1307
1308   VisualFactory factory = VisualFactory::Get();
1309   Visual::Base visual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions( 2000, 2000 ) );
1310   DALI_TEST_CHECK( visual );
1311
1312   TestGlAbstraction& gl = application.GetGlAbstraction();
1313   TraceCallStack& textureTrace = gl.GetTextureTrace();
1314   textureTrace.Enable(true);
1315
1316   DummyControl actor = DummyControl::New(true);
1317   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1318   actor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS ); // Only rasterizes when it knows control size.
1319   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1320   application.GetScene().Add( actor );
1321
1322   // Either application.SendNotification() or the trigger can now complete the task.
1323   application.SendNotification();
1324   application.Render();
1325   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1326
1327   // renderer is added to actor
1328   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1329
1330   // waiting for the resource uploading
1331   application.SendNotification();
1332   application.Render();
1333
1334   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1335
1336   END_TEST;
1337 }
1338
1339 int UtcDaliVisualFactoryGetSvgVisualAtlas(void)
1340 {
1341   ToolkitTestApplication application;
1342   tet_infoline( "UtcDaliVisualFactoryGetSvgVisual: Request svg visual with enabled atlas" );
1343
1344   VisualFactory factory = VisualFactory::Get();
1345
1346   Property::Map propertyMap;
1347   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::SVG );
1348   propertyMap.Insert( ImageVisual::Property::URL, TEST_SVG_FILE_NAME );
1349   propertyMap.Insert( ImageVisual::Property::ATLASING, true );
1350
1351   Visual::Base visual = factory.CreateVisual( propertyMap );
1352   DALI_TEST_CHECK( visual );
1353
1354   TestGlAbstraction& gl = application.GetGlAbstraction();
1355   TraceCallStack& textureTrace = gl.GetTextureTrace();
1356   textureTrace.Enable(true);
1357
1358   DummyControl actor = DummyControl::New(true);
1359   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1360   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1361   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1362   application.GetScene().Add( actor );
1363   visual.SetTransformAndSize(DefaultTransform(), Vector2(200.f, 200.f) );
1364
1365   // Either application.SendNotification() or the trigger can now complete the task.
1366   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1367   application.SendNotification();
1368   application.Render();
1369   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1370
1371   // renderer is added to actor
1372   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1373
1374   // waiting for the resource uploading
1375   application.SendNotification();
1376   application.Render();
1377
1378   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1379
1380   END_TEST;
1381 }
1382
1383 //Creates a mesh visual from the given propertyMap and tries to load it on stage in the given application.
1384 //This is expected to succeed, which will then pass the test.
1385 void MeshVisualLoadsCorrectlyTest( Property::Map& propertyMap, ToolkitTestApplication& application )
1386 {
1387   VisualFactory factory = VisualFactory::Get();
1388   DALI_TEST_CHECK( factory );
1389
1390   //Create a mesh visual.
1391   Visual::Base visual = factory.CreateVisual( propertyMap );
1392   DALI_TEST_CHECK( visual );
1393
1394   //Create an actor on stage to house the visual.
1395   DummyControl actor = DummyControl::New(true);
1396   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1397   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1398   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1399   application.GetScene().Add( actor );
1400   visual.SetTransformAndSize(DefaultTransform(), Vector2( 200.f, 200.f ) );
1401
1402   //Ensure set on stage.
1403   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1404
1405   //Attempt to render to queue resource load requests.
1406   application.SendNotification();
1407   application.Render( 0 );
1408
1409   //Render again to upload the now-loaded textures.
1410   application.SendNotification();
1411   application.Render( 0 );
1412
1413   Matrix testScaleMatrix;
1414   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1415   Matrix actualScaleMatrix;
1416
1417   //Test to see if the object has been successfully loaded.
1418   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1419   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1420
1421   //Finish by setting off stage, and ensuring this was successful.
1422   actor.Unparent();
1423   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1424 }
1425
1426 //Creates a mesh visual from the given propertyMap and tries to load it on stage in the given application.
1427 //This is expected to fail, which will then pass the test.
1428 void MeshVisualDoesNotLoadCorrectlyTest( Property::Map& propertyMap, ToolkitTestApplication& application )
1429 {
1430   VisualFactory factory = VisualFactory::Get();
1431   DALI_TEST_CHECK( factory );
1432
1433   //Create a mesh visual.
1434   Visual::Base visual = factory.CreateVisual( propertyMap );
1435   DALI_TEST_CHECK( visual );
1436
1437   //Create an actor on stage to house the visual.
1438   DummyControl actor = DummyControl::New(true);
1439   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1440   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1441   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1442   application.GetScene().Add( actor );
1443   visual.SetTransformAndSize(DefaultTransform(),  Vector2( 200.f, 200.f ) );
1444
1445   //Ensure set on stage.
1446   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1447
1448   //Attempt to render to queue resource load requests.
1449   application.SendNotification();
1450   application.Render( 0 );
1451
1452   //Render again to upload the now-loaded textures.
1453   application.SendNotification();
1454   application.Render( 0 );
1455
1456   //Test to see if the object has not been loaded, as expected.
1457   Matrix scaleMatrix;
1458   DALI_TEST_CHECK( !application.GetGlAbstraction().GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1459
1460   //Finish by setting off stage, and ensuring this was successful.
1461   actor.Unparent();
1462   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1463 }
1464
1465 //Test if mesh loads correctly when supplied with only the bare minimum requirements, an object file.
1466 int UtcDaliVisualFactoryGetMeshVisual1(void)
1467 {
1468   //Set up test application first, so everything else can be handled.
1469   ToolkitTestApplication application;
1470
1471   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual1:  Request mesh visual with a valid object file only" );
1472
1473   static std::vector<UniformData> customUniforms =
1474   {
1475     UniformData("uObjectMatrix", Property::Type::MATRIX),
1476   };
1477
1478   TestGraphicsController& graphics = application.GetGraphicsController();
1479   graphics.AddCustomUniforms(customUniforms);
1480
1481   //Set up visual properties.
1482   Property::Map propertyMap;
1483   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::MESH );
1484   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1485
1486   //Test to see if mesh loads correctly.
1487   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1488
1489   END_TEST;
1490 }
1491
1492
1493 //Test if mesh loads correctly when supplied with an object file as well as a blank material file and images directory.
1494 int UtcDaliVisualFactoryGetMeshVisual2(void)
1495 {
1496   //Set up test application first, so everything else can be handled.
1497   ToolkitTestApplication application;
1498
1499   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual2:  Request mesh visual with blank material file and images directory" );
1500
1501   static std::vector<UniformData> customUniforms =
1502   {
1503     UniformData("uObjectMatrix", Property::Type::MATRIX),
1504   };
1505
1506   TestGraphicsController& graphics = application.GetGraphicsController();
1507   graphics.AddCustomUniforms(customUniforms);
1508
1509   //Set up visual properties.
1510   Property::Map propertyMap;
1511   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1512   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1513   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, "" );
1514   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, "" );
1515
1516   //Test to see if mesh loads correctly.
1517   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1518
1519   END_TEST;
1520 }
1521
1522 //Test if mesh loads correctly when supplied with all main parameters, an object file, a material file and a directory location, but duff optional parameters
1523 int UtcDaliVisualFactoryGetMeshVisual3b(void)
1524 {
1525   //Set up test application first, so everything else can be handled.
1526   ToolkitTestApplication application;
1527
1528   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual3:  Request mesh visual with all parameters correct" );
1529
1530   static std::vector<UniformData> customUniforms =
1531   {
1532     UniformData("uObjectMatrix", Property::Type::MATRIX),
1533   };
1534
1535   TestGraphicsController& graphics = application.GetGraphicsController();
1536   graphics.AddCustomUniforms(customUniforms);
1537
1538   //Set up visual properties.
1539   Property::Map propertyMap;
1540   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1541   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1542   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1543   propertyMap.Insert( MeshVisual::Property::USE_MIPMAPPING, Color::GREEN ); // Test that wrong property types don't prevent the object load
1544   propertyMap.Insert( MeshVisual::Property::USE_SOFT_NORMALS, 1.0f );
1545   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, 1.0f );
1546   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1547
1548   //Test to see if mesh loads correctly.
1549   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1550
1551   END_TEST;
1552 }
1553
1554 //Test if mesh loads correctly when supplied with all main parameters, an object file, a material file and a directory location.
1555 int UtcDaliVisualFactoryGetMeshVisual3(void)
1556 {
1557   //Set up test application first, so everything else can be handled.
1558   ToolkitTestApplication application;
1559
1560   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual3:  Request mesh visual with all parameters correct" );
1561
1562   static std::vector<UniformData> customUniforms =
1563   {
1564     UniformData("uObjectMatrix", Property::Type::MATRIX),
1565   };
1566
1567   TestGraphicsController& graphics = application.GetGraphicsController();
1568   graphics.AddCustomUniforms(customUniforms);
1569
1570   //Set up visual properties.
1571   Property::Map propertyMap;
1572   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1573   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1574   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1575   propertyMap.Insert( MeshVisual::Property::USE_MIPMAPPING, false );
1576   propertyMap.Insert( MeshVisual::Property::USE_SOFT_NORMALS, false );
1577   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3::XAXIS );
1578   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1579
1580   //Test to see if mesh loads correctly.
1581   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1582
1583   END_TEST;
1584 }
1585
1586 //Test if mesh visual can load a correctly supplied mesh without a normal map or gloss map in the material file.
1587 int UtcDaliVisualFactoryGetMeshVisual4(void)
1588 {
1589   //Set up test application first, so everything else can be handled.
1590   ToolkitTestApplication application;
1591
1592   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual4:  Request mesh visual with diffuse texture but not normal or gloss." );
1593
1594   static std::vector<UniformData> customUniforms =
1595   {
1596     UniformData("uObjectMatrix", Property::Type::MATRIX),
1597   };
1598
1599   TestGraphicsController& graphics = application.GetGraphicsController();
1600   graphics.AddCustomUniforms(customUniforms);
1601
1602   //Set up visual properties.
1603   Property::Map propertyMap;
1604   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1605   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1606   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_SIMPLE_MTL_FILE_NAME );
1607   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1608
1609   //Test to see if mesh loads correctly.
1610   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1611
1612   END_TEST;
1613 }
1614
1615 //Test if mesh visual can load when made to use diffuse textures only.
1616 int UtcDaliVisualFactoryGetMeshVisual5(void)
1617 {
1618   //Set up test application first, so everything else can be handled.
1619   ToolkitTestApplication application;
1620
1621   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual5:  Request mesh visual and make it only use diffuse textures." );
1622
1623   static std::vector<UniformData> customUniforms =
1624   {
1625     UniformData("uObjectMatrix", Property::Type::MATRIX),
1626   };
1627
1628   TestGraphicsController& graphics = application.GetGraphicsController();
1629   graphics.AddCustomUniforms(customUniforms);
1630
1631   //Set up visual properties.
1632   Property::Map propertyMap;
1633   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1634   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1635   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1636   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1637   propertyMap.Insert( "useMipmapping", false );
1638   propertyMap.Insert( "useSoftNormals", false );
1639   propertyMap.Insert( "lightPosition", Vector3::ZAXIS );
1640   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURED_WITH_SPECULAR_LIGHTING );
1641
1642   //Test to see if mesh loads correctly.
1643   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1644
1645
1646   END_TEST;
1647 }
1648
1649 //Test if mesh visual can load when made to not use the supplied textures.
1650 int UtcDaliVisualFactoryGetMeshVisual6(void)
1651 {
1652   //Set up test application first, so everything else can be handled.
1653   ToolkitTestApplication application;
1654
1655   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual6:  Request mesh visual and make it not use any textures." );
1656
1657   static std::vector<UniformData> customUniforms =
1658   {
1659     UniformData("uObjectMatrix", Property::Type::MATRIX),
1660   };
1661
1662   TestGraphicsController& graphics = application.GetGraphicsController();
1663   graphics.AddCustomUniforms(customUniforms);
1664
1665   //Set up visual properties.
1666   Property::Map propertyMap;
1667   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1668   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1669   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1670   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1671   propertyMap.Insert( MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
1672
1673   //Test to see if mesh loads correctly.
1674   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1675
1676   END_TEST;
1677 }
1678 //Test if mesh visual loads correctly when light position is manually set.
1679 int UtcDaliVisualFactoryGetMeshVisual7(void)
1680 {
1681   //Set up test application first, so everything else can be handled.
1682   ToolkitTestApplication application;
1683
1684   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual7:  Request mesh visual with custom light position." );
1685
1686   static std::vector<UniformData> customUniforms =
1687   {
1688     UniformData("uObjectMatrix", Property::Type::MATRIX),
1689   };
1690
1691   TestGraphicsController& graphics = application.GetGraphicsController();
1692   graphics.AddCustomUniforms(customUniforms);
1693
1694   //Set up visual properties.
1695   Property::Map propertyMap;
1696   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1697   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1698   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1699   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1700   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 0.0, 1.0, 2.0 ) );
1701
1702   //Test to see if mesh loads correctly.
1703   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1704
1705   END_TEST;
1706 }
1707
1708 //Test if mesh visual loads correctly when supplied an object file without face normals or texture points.
1709 //Note that this notably tests object loader functionality.
1710 int UtcDaliVisualFactoryGetMeshVisual8(void)
1711 {
1712   //Set up test application first, so everything else can be handled.
1713   ToolkitTestApplication application;
1714
1715   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual5:  Request mesh visual with normal-less object file." );
1716
1717   static std::vector<UniformData> customUniforms =
1718   {
1719     UniformData("uObjectMatrix", Property::Type::MATRIX),
1720   };
1721
1722   TestGraphicsController& graphics = application.GetGraphicsController();
1723   graphics.AddCustomUniforms(customUniforms);
1724
1725   //Set up visual properties.
1726   Property::Map propertyMap;
1727   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1728   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_SIMPLE_OBJ_FILE_NAME );
1729   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1730   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1731
1732   //Test to see if mesh loads correctly.
1733   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1734
1735   END_TEST;
1736 }
1737
1738 //Test if mesh visual handles the case of lacking an object file.
1739 int UtcDaliVisualFactoryGetMeshVisualN1(void)
1740 {
1741   //Set up test application first, so everything else can be handled.
1742   ToolkitTestApplication application;
1743
1744   tet_infoline( "UtcDaliVisualFactoryGetMeshVisualN1:  Request mesh visual without object file" );
1745
1746   //Set up visual properties.
1747   Property::Map propertyMap;
1748   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1749   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1750   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1751
1752   //Test to see if mesh doesn't load with these properties, as expected.
1753   MeshVisualDoesNotLoadCorrectlyTest( propertyMap, application );
1754
1755
1756   END_TEST;
1757 }
1758
1759 //Test if mesh visual handles the case of being passed invalid material and images urls.
1760 int UtcDaliVisualFactoryGetMeshVisualN2(void)
1761 {
1762   //Set up test application first, so everything else can be handled.
1763   ToolkitTestApplication application;
1764
1765   tet_infoline( "UtcDaliVisualFactoryGetMeshVisualN2:  Request mesh visual with invalid material and images urls" );
1766
1767   //Set up visual properties.
1768   Property::Map propertyMap;
1769   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1770   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1771   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, "invalid" );
1772   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, "also invalid" );
1773
1774   //Test to see if mesh doesn't load with these properties, as expected.
1775   MeshVisualDoesNotLoadCorrectlyTest( propertyMap, application );
1776
1777
1778   END_TEST;
1779 }
1780
1781 //Test if mesh visual handles the case of being passed an invalid object url
1782 int UtcDaliVisualFactoryGetMeshVisualN3(void)
1783 {
1784   //Set up test application first, so everything else can be handled.
1785   ToolkitTestApplication application;
1786   tet_infoline( "UtcDaliVisualFactoryGetMeshVisualN3:  Request mesh visual with invalid object url" );
1787
1788
1789   //Set up visual properties.
1790   Property::Map propertyMap;
1791   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1792   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, "invalid" );
1793   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1794   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1795
1796   //Test to see if mesh doesn't load with these properties, as expected.
1797   MeshVisualDoesNotLoadCorrectlyTest( propertyMap, application );
1798
1799   END_TEST;
1800 }
1801
1802 //Creates a primitive visual with the given property map and tests to see if it correctly loads in the given application.
1803 void TestPrimitiveVisualWithProperties( Property::Map& propertyMap, ToolkitTestApplication& application )
1804 {
1805   VisualFactory factory = VisualFactory::Get();
1806   DALI_TEST_CHECK( factory );
1807
1808   //Create a primitive visual.
1809   Visual::Base visual = factory.CreateVisual( propertyMap );
1810   DALI_TEST_CHECK( visual );
1811
1812   //Create an actor on stage to house the visual.
1813   DummyControl actor = DummyControl::New(true);
1814   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1815   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1816
1817   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1818   application.GetScene().Add( actor );
1819   visual.SetTransformAndSize(DefaultTransform(),  Vector2( 200.f, 200.f ) );
1820
1821   //Ensure set on stage.
1822   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1823
1824   //Tell test application to load the visual.
1825   application.SendNotification();
1826   application.Render(0);
1827
1828   Matrix testScaleMatrix;
1829   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1830   Matrix actualScaleMatrix;
1831
1832   //Test to see if the object has been successfully loaded.
1833   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1834   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1835
1836   //Finish by setting off stage, and ensuring this was successful.
1837   actor.Unparent();
1838   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1839 }
1840
1841 //Test if primitive shape loads correctly when supplied with only the bare minimum requirements, the shape to use.
1842 int UtcDaliVisualFactoryGetPrimitiveVisual1(void)
1843 {
1844   //Set up test application first, so everything else can be handled.
1845   ToolkitTestApplication application;
1846
1847   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual1:  Request primitive visual with a shape only" );
1848
1849   static std::vector<UniformData> customUniforms =
1850   {
1851     UniformData("uObjectMatrix", Property::Type::MATRIX),
1852   };
1853
1854   TestGraphicsController& graphics = application.GetGraphicsController();
1855   graphics.AddCustomUniforms(customUniforms);
1856
1857   //Set up visual properties.
1858   Property::Map propertyMap;
1859   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1860   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
1861
1862   //Test to see if shape loads correctly.
1863   TestPrimitiveVisualWithProperties( propertyMap, application );
1864
1865   END_TEST;
1866 }
1867
1868 //Test if primitive shape loads correctly when supplied with all possible parameters
1869 int UtcDaliVisualFactoryGetPrimitiveVisual2(void)
1870 {
1871   //Set up test application first, so everything else can be handled.
1872   ToolkitTestApplication application;
1873
1874   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual2:  Request primitive visual with everything" );
1875
1876   static std::vector<UniformData> customUniforms =
1877   {
1878     UniformData("uObjectMatrix", Property::Type::MATRIX),
1879   };
1880
1881   TestGraphicsController& graphics = application.GetGraphicsController();
1882   graphics.AddCustomUniforms(customUniforms);
1883
1884   //Set up visual properties.
1885   Property::Map propertyMap;
1886   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1887   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
1888   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1889   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
1890   propertyMap.Insert( PrimitiveVisual::Property::STACKS, 20 );
1891   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
1892   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
1893   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
1894   propertyMap.Insert( PrimitiveVisual::Property::SCALE_RADIUS, 60.0f );
1895   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.7f );
1896   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.8f );
1897   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 0.9, 1.0, 1.1 ) );
1898
1899   //Test to see if shape loads correctly.
1900   TestPrimitiveVisualWithProperties( propertyMap, application );
1901
1902   END_TEST;
1903 }
1904
1905 //Test if primitive shape loads a sphere correctly.
1906 int UtcDaliVisualFactoryGetPrimitiveVisual3(void)
1907 {
1908   //Set up test application first, so everything else can be handled.
1909   ToolkitTestApplication application;
1910
1911   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual3:  Request primitive visual to display a sphere" );
1912
1913   static std::vector<UniformData> customUniforms =
1914   {
1915     UniformData("uObjectMatrix", Property::Type::MATRIX),
1916   };
1917
1918   TestGraphicsController& graphics = application.GetGraphicsController();
1919   graphics.AddCustomUniforms(customUniforms);
1920
1921   //Set up visual properties.
1922   Property::Map propertyMap;
1923   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1924   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
1925   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1926   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
1927   propertyMap.Insert( PrimitiveVisual::Property::STACKS, 20 );
1928
1929   //Test to see if shape loads correctly.
1930   TestPrimitiveVisualWithProperties( propertyMap, application );
1931
1932   END_TEST;
1933 }
1934
1935 //Test if primitive shape loads a conic section correctly.
1936 int UtcDaliVisualFactoryGetPrimitiveVisual4(void)
1937 {
1938   //Set up test application first, so everything else can be handled.
1939   ToolkitTestApplication application;
1940
1941   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual4:  Request primitive visual to display a conic section" );
1942
1943   static std::vector<UniformData> customUniforms =
1944   {
1945     UniformData("uObjectMatrix", Property::Type::MATRIX),
1946   };
1947
1948   TestGraphicsController& graphics = application.GetGraphicsController();
1949   graphics.AddCustomUniforms(customUniforms);
1950
1951   //Set up visual properties.
1952   Property::Map propertyMap;
1953   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1954   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CONICAL_FRUSTUM );
1955   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1956   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
1957   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
1958   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
1959   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
1960
1961   //Test to see if shape loads correctly.
1962   TestPrimitiveVisualWithProperties( propertyMap, application );
1963
1964   END_TEST;
1965 }
1966
1967 //Test if primitive shape loads a bevelled cube correctly.
1968 int UtcDaliVisualFactoryGetPrimitiveVisual5(void)
1969 {
1970   //Set up test application first, so everything else can be handled.
1971   ToolkitTestApplication application;
1972
1973   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual5:  Request primitive visual to display a bevelled cube" );
1974
1975   static std::vector<UniformData> customUniforms =
1976   {
1977     UniformData("uObjectMatrix", Property::Type::MATRIX),
1978   };
1979
1980   TestGraphicsController& graphics = application.GetGraphicsController();
1981   graphics.AddCustomUniforms(customUniforms);
1982
1983   //Set up visual properties.
1984   Property::Map propertyMap;
1985   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1986   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::BEVELLED_CUBE );
1987   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1988   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.7f );
1989
1990   //Test to see if shape loads correctly.
1991   TestPrimitiveVisualWithProperties( propertyMap, application );
1992
1993   END_TEST;
1994 }
1995
1996 //Test if primitive shape loads an octahedron correctly.
1997 int UtcDaliVisualFactoryGetPrimitiveVisual6(void)
1998 {
1999   //Set up test application first, so everything else can be handled.
2000   ToolkitTestApplication application;
2001
2002   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual6:  Request primitive visual to display an octahedron" );
2003
2004   static std::vector<UniformData> customUniforms =
2005   {
2006     UniformData("uObjectMatrix", Property::Type::MATRIX),
2007   };
2008
2009   TestGraphicsController& graphics = application.GetGraphicsController();
2010   graphics.AddCustomUniforms(customUniforms);
2011
2012   //Set up visual properties.
2013   Property::Map propertyMap;
2014   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2015   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::OCTAHEDRON );
2016   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
2017
2018   //Test to see if shape loads correctly.
2019   TestPrimitiveVisualWithProperties( propertyMap, application );
2020
2021   END_TEST;
2022 }
2023
2024 //Test if primitive shape loads a cone correctly.
2025 int UtcDaliVisualFactoryGetPrimitiveVisual7(void)
2026 {
2027   //Set up test application first, so everything else can be handled.
2028   ToolkitTestApplication application;
2029
2030   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual7:  Request primitive visual to display a cone" );
2031
2032   static std::vector<UniformData> customUniforms =
2033   {
2034     UniformData("uObjectMatrix", Property::Type::MATRIX),
2035   };
2036
2037   TestGraphicsController& graphics = application.GetGraphicsController();
2038   graphics.AddCustomUniforms(customUniforms);
2039
2040   //Set up visual properties.
2041   Property::Map propertyMap;
2042   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2043   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CONE );
2044   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
2045   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
2046   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
2047   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
2048
2049   //Test to see if shape loads correctly.
2050   TestPrimitiveVisualWithProperties( propertyMap, application );
2051
2052   END_TEST;
2053 }
2054
2055 //Test if primitive shape loads correctly when light position is manually set.
2056 int UtcDaliVisualFactoryGetPrimitiveVisual8(void)
2057 {
2058   //Set up test application first, so everything else can be handled.
2059   ToolkitTestApplication application;
2060
2061   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual8:  Request primitive visual with set light position" );
2062
2063   static std::vector<UniformData> customUniforms =
2064   {
2065     UniformData("uObjectMatrix", Property::Type::MATRIX),
2066   };
2067
2068   TestGraphicsController& graphics = application.GetGraphicsController();
2069   graphics.AddCustomUniforms(customUniforms);
2070
2071   //Set up visual properties.
2072   Property::Map propertyMap;
2073   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2074   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2075   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
2076   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 0.0, 1.0, 2.0 ) );
2077
2078   //Test to see if shape loads correctly.
2079   TestPrimitiveVisualWithProperties( propertyMap, application );
2080
2081   END_TEST;
2082 }
2083
2084 //Test if primitive shape loads correctly when told to use too many slices.
2085 int UtcDaliVisualFactoryGetPrimitiveVisual9(void)
2086 {
2087   //Set up test application first, so everything else can be handled.
2088   ToolkitTestApplication application;
2089
2090   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual9:  Request primitive visual with above-cap slices." );
2091
2092   static std::vector<UniformData> customUniforms =
2093   {
2094     UniformData("uObjectMatrix", Property::Type::MATRIX),
2095   };
2096
2097   TestGraphicsController& graphics = application.GetGraphicsController();
2098   graphics.AddCustomUniforms(customUniforms);
2099
2100   //Set up visual properties.
2101   Property::Map propertyMap;
2102   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2103   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2104   propertyMap.Insert( PrimitiveVisual::Property::SLICES, Property::Value( 1000000 ) );
2105
2106   //Test to see if shape loads correctly.
2107   TestPrimitiveVisualWithProperties( propertyMap, application );
2108
2109   END_TEST;
2110 }
2111
2112 //Test if primitive shape loads correctly when told to use too few slices. (2 slices or less.)
2113 int UtcDaliVisualFactoryGetPrimitiveVisual10(void)
2114 {
2115   //Set up test application first, so everything else can be handled.
2116   ToolkitTestApplication application;
2117
2118   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual10:  Request primitive visual with too few slices." );
2119
2120   static std::vector<UniformData> customUniforms =
2121   {
2122     UniformData("uObjectMatrix", Property::Type::MATRIX),
2123   };
2124
2125   TestGraphicsController& graphics = application.GetGraphicsController();
2126   graphics.AddCustomUniforms(customUniforms);
2127
2128   //Set up visual properties.
2129   Property::Map propertyMap;
2130   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2131   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2132   propertyMap.Insert( PrimitiveVisual::Property::SLICES, Property::Value( 2 ) );
2133
2134   //Test to see if shape loads correctly.
2135   TestPrimitiveVisualWithProperties( propertyMap, application );
2136
2137   END_TEST;
2138 }
2139
2140 //Test if primitive shape loads correctly when told to use too many stacks.
2141 int UtcDaliVisualFactoryGetPrimitiveVisual11(void)
2142 {
2143   //Set up test application first, so everything else can be handled.
2144   ToolkitTestApplication application;
2145
2146   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual11:  Request primitive visual with too many stacks." );
2147
2148   static std::vector<UniformData> customUniforms =
2149   {
2150     UniformData("uObjectMatrix", Property::Type::MATRIX),
2151   };
2152
2153   TestGraphicsController& graphics = application.GetGraphicsController();
2154   graphics.AddCustomUniforms(customUniforms);
2155
2156   //Set up visual properties.
2157   Property::Map propertyMap;
2158   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2159   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2160   propertyMap.Insert( PrimitiveVisual::Property::STACKS, Property::Value( 1000000 ) );
2161
2162   //Test to see if shape loads correctly.
2163   TestPrimitiveVisualWithProperties( propertyMap, application );
2164
2165   END_TEST;
2166 }
2167
2168 //Test if primitive shape loads correctly when told to use too few stacks. (1 stack or less.)
2169 int UtcDaliVisualFactoryGetPrimitiveVisual12(void)
2170 {
2171   //Set up test application first, so everything else can be handled.
2172   ToolkitTestApplication application;
2173
2174   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual12:  Request primitive visual with too few stacks." );
2175
2176   static std::vector<UniformData> customUniforms =
2177   {
2178     UniformData("uObjectMatrix", Property::Type::MATRIX),
2179   };
2180
2181   TestGraphicsController& graphics = application.GetGraphicsController();
2182   graphics.AddCustomUniforms(customUniforms);
2183
2184   //Set up visual properties.
2185   Property::Map propertyMap;
2186   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2187   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2188   propertyMap.Insert( PrimitiveVisual::Property::STACKS, Property::Value( 1 ) );
2189
2190   //Test to see if shape loads correctly.
2191   TestPrimitiveVisualWithProperties( propertyMap, application );
2192
2193   END_TEST;
2194 }
2195
2196 //Test if primitive shape loads correctly when told to use invalid (zero or negative) dimensions.
2197 int UtcDaliVisualFactoryGetPrimitiveVisual13(void)
2198 {
2199   //Set up test application first, so everything else can be handled.
2200   ToolkitTestApplication application;
2201
2202   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual13:  Request primitive visual with invalid scale dimensions." );
2203
2204   static std::vector<UniformData> customUniforms =
2205   {
2206     UniformData("uObjectMatrix", Property::Type::MATRIX),
2207   };
2208
2209   TestGraphicsController& graphics = application.GetGraphicsController();
2210   graphics.AddCustomUniforms(customUniforms);
2211
2212   //Set up visual properties.
2213   Property::Map propertyMap;
2214   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2215   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2216   propertyMap.Insert( PrimitiveVisual::Property::SCALE_DIMENSIONS, Vector3::ZERO );
2217
2218   //Test to see if shape loads correctly.
2219   TestPrimitiveVisualWithProperties( propertyMap, application );
2220
2221   END_TEST;
2222 }
2223
2224 //Test if primitive shape loads correctly when told to use too low a bevel percentage.
2225 int UtcDaliVisualFactoryGetPrimitiveVisual14(void)
2226 {
2227   //Set up test application first, so everything else can be handled.
2228   ToolkitTestApplication application;
2229
2230   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual14:  Request primitive visual with too low a bevel percentage." );
2231
2232   static std::vector<UniformData> customUniforms =
2233   {
2234     UniformData("uObjectMatrix", Property::Type::MATRIX),
2235   };
2236
2237   TestGraphicsController& graphics = application.GetGraphicsController();
2238   graphics.AddCustomUniforms(customUniforms);
2239
2240   //Set up visual properties.
2241   Property::Map propertyMap;
2242   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2243   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2244   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::Value( -1.0f ) );
2245
2246   //Test to see if shape loads correctly.
2247   TestPrimitiveVisualWithProperties( propertyMap, application );
2248
2249   END_TEST;
2250 }
2251
2252 //Test if primitive shape loads correctly when told to use too high a bevel percentage.
2253 int UtcDaliVisualFactoryGetPrimitiveVisual15(void)
2254 {
2255   //Set up test application first, so everything else can be handled.
2256   ToolkitTestApplication application;
2257
2258   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual15:  Request primitive visual with too high a bevel percentage." );
2259
2260   static std::vector<UniformData> customUniforms =
2261   {
2262     UniformData("uObjectMatrix", Property::Type::MATRIX),
2263   };
2264
2265   TestGraphicsController& graphics = application.GetGraphicsController();
2266   graphics.AddCustomUniforms(customUniforms);
2267
2268   //Set up visual properties.
2269   Property::Map propertyMap;
2270   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2271   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2272   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::Value( 2.0f ) );
2273
2274   //Test to see if shape loads correctly.
2275   TestPrimitiveVisualWithProperties( propertyMap, application );
2276
2277   END_TEST;
2278 }
2279
2280 //Test if primitive shape loads correctly when told to use too low a bevel smoothness.
2281 int UtcDaliVisualFactoryGetPrimitiveVisual16(void)
2282 {
2283   //Set up test application first, so everything else can be handled.
2284   ToolkitTestApplication application;
2285
2286   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual16:  Request primitive visual with too low a bevel smoothness." );
2287
2288   static std::vector<UniformData> customUniforms =
2289   {
2290     UniformData("uObjectMatrix", Property::Type::MATRIX),
2291   };
2292
2293   TestGraphicsController& graphics = application.GetGraphicsController();
2294   graphics.AddCustomUniforms(customUniforms);
2295
2296   //Set up visual properties.
2297   Property::Map propertyMap;
2298   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2299   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2300   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::Value( -1.0f ) );
2301
2302   //Test to see if shape loads correctly.
2303   TestPrimitiveVisualWithProperties( propertyMap, application );
2304
2305   END_TEST;
2306 }
2307
2308 //Test if primitive shape loads correctly when told to use too high a bevel smoothness.
2309 int UtcDaliVisualFactoryGetPrimitiveVisual17(void)
2310 {
2311   //Set up test application first, so everything else can be handled.
2312   ToolkitTestApplication application;
2313
2314   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual17:  Request primitive visual with too high a bevel smoothness." );
2315
2316   static std::vector<UniformData> customUniforms =
2317   {
2318     UniformData("uObjectMatrix", Property::Type::MATRIX),
2319   };
2320
2321   TestGraphicsController& graphics = application.GetGraphicsController();
2322   graphics.AddCustomUniforms(customUniforms);
2323
2324   //Set up visual properties.
2325   Property::Map propertyMap;
2326   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2327   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2328   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::Value( 2.0f ) );
2329
2330   //Test to see if shape loads correctly.
2331   TestPrimitiveVisualWithProperties( propertyMap, application );
2332
2333   END_TEST;
2334 }
2335
2336 //Test if primitive shape loads a conic section correctly.
2337 int UtcDaliVisualFactoryGetPrimitiveVisual18(void)
2338 {
2339   //Set up test application first, so everything else can be handled.
2340   ToolkitTestApplication application;
2341
2342   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual18:  Request primitive visual to display a conic section" );
2343
2344   static std::vector<UniformData> customUniforms =
2345   {
2346     UniformData("uObjectMatrix", Property::Type::MATRIX),
2347   };
2348
2349   TestGraphicsController& graphics = application.GetGraphicsController();
2350   graphics.AddCustomUniforms(customUniforms);
2351
2352   //Set up visual properties.
2353   Property::Map propertyMap;
2354   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2355   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CONICAL_FRUSTUM );
2356   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
2357   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
2358   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
2359   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
2360   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
2361
2362   //Test to see if shape loads correctly.
2363   TestPrimitiveVisualWithProperties( propertyMap, application );
2364
2365   END_TEST;
2366 }
2367
2368 //Test if primitive shape visual handles the case of not being passed a specific shape to use.
2369 int UtcDaliVisualFactoryGetPrimitiveVisualN1(void)
2370 {
2371   //Set up test application first, so everything else can be handled.
2372   ToolkitTestApplication application;
2373
2374   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisualN1:  Request primitive visual without shape" );
2375
2376   static std::vector<UniformData> customUniforms =
2377   {
2378     UniformData("uObjectMatrix", Property::Type::MATRIX),
2379   };
2380
2381   TestGraphicsController& graphics = application.GetGraphicsController();
2382   graphics.AddCustomUniforms(customUniforms);
2383
2384   //Set up visual properties, without supplying shape.
2385   Property::Map propertyMap;
2386   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2387
2388   //Test to see if shape loads regardless of missing input.
2389   TestPrimitiveVisualWithProperties( propertyMap, application );
2390
2391   END_TEST;
2392 }
2393
2394 int UtcDaliVisualFactoryGetAnimatedImageVisual1(void)
2395 {
2396   ToolkitTestApplication application;
2397   tet_infoline( "UtcDaliVisualFactoryGetAnimatedImageVisual1: Request animated image visual with a gif url" );
2398
2399   TestGlAbstraction& gl = application.GetGlAbstraction();
2400   TraceCallStack& textureTrace = gl.GetTextureTrace();
2401   textureTrace.Enable(true);
2402
2403   VisualFactory factory = VisualFactory::Get();
2404   Visual::Base visual = factory.CreateVisual( TEST_GIF_FILE_NAME, ImageDimensions() );
2405   DALI_TEST_CHECK( visual );
2406
2407   DummyControl actor = DummyControl::New(true);
2408   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
2409   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2410   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
2411   application.GetScene().Add( actor );
2412
2413   application.SendNotification();
2414   application.Render();
2415
2416   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 2 ), true, TEST_LOCATION );
2417
2418   application.SendNotification();
2419   application.Render();
2420
2421   // renderer is added to actor
2422   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
2423   Renderer renderer = actor.GetRendererAt( 0u );
2424   DALI_TEST_CHECK( renderer );
2425
2426   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2427   textureTrace.Reset();
2428
2429   // Force the timer used by the animatedImageVisual to tick,
2430   Dali::Timer timer = Timer::New( 0 );
2431   timer.MockEmitSignal();
2432   application.SendNotification();
2433   application.Render();
2434
2435   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2436
2437   application.SendNotification();
2438   application.Render();
2439   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2440   textureTrace.Reset();
2441
2442   // Force the timer used by the animatedImageVisual to tick,
2443   timer.MockEmitSignal();
2444   application.SendNotification();
2445   application.Render();
2446
2447   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2448
2449   application.SendNotification();
2450   application.Render();
2451   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2452   textureTrace.Reset();
2453
2454   // Force the timer used by the animatedImageVisual to tick,
2455   timer.MockEmitSignal();
2456   application.SendNotification();
2457   application.Render();
2458
2459   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2460
2461   application.SendNotification();
2462   application.Render();
2463   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2464   textureTrace.Reset();
2465
2466   // Test SetOffScene().
2467   actor.Unparent();
2468   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2469
2470   END_TEST;
2471 }
2472
2473 int UtcDaliVisualFactoryGetAnimatedImageVisual2(void)
2474 {
2475   ToolkitTestApplication application;
2476   tet_infoline( "UtcDaliVisualFactoryGetAnimatedImageVisual2: Request animated image visual with a Property::Map, test custom wrap mode and pixel area" );
2477
2478   static std::vector<UniformData> customUniforms =
2479   {
2480     UniformData("pixelArea", Property::Type::VECTOR4),
2481     UniformData("wrapMode", Property::Type::VECTOR2),
2482   };
2483
2484   TestGraphicsController& graphics = application.GetGraphicsController();
2485   graphics.AddCustomUniforms(customUniforms);
2486
2487   const Vector4 pixelArea(-0.5f, -0.5f, 2.f, 2.f);
2488   Property::Map propertyMap;
2489   propertyMap.Add( Toolkit::Visual::Property::TYPE,  Visual::IMAGE  )
2490              .Add( ImageVisual::Property::URL, TEST_GIF_FILE_NAME  )
2491              .Add( ImageVisual::Property::PIXEL_AREA, pixelArea )
2492              .Add( ImageVisual::Property::WRAP_MODE_U, WrapMode::MIRRORED_REPEAT )
2493              .Add( ImageVisual::Property::WRAP_MODE_V, WrapMode::REPEAT );
2494
2495   Visual::Base visual = VisualFactory::Get().CreateVisual( propertyMap );
2496   DALI_TEST_CHECK( visual );
2497
2498   TestGlAbstraction& gl = application.GetGlAbstraction();
2499   TraceCallStack& textureTrace = gl.GetTextureTrace();
2500   textureTrace.Enable(true);
2501   TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
2502   texParameterTrace.Enable( true );
2503
2504   DummyControl actor = DummyControl::New(true);
2505   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
2506   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
2507   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
2508   application.GetScene().Add( actor );
2509
2510   application.SendNotification();
2511   application.Render();
2512
2513   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 2 ), true, TEST_LOCATION );
2514
2515   application.SendNotification();
2516   application.Render();
2517
2518   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
2519
2520   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
2521
2522   // For animated image visual, the wrapping is handled manually in shader, so the following gl function should not be called
2523   std::stringstream out;
2524   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_S << ", " << GL_MIRRORED_REPEAT;
2525   DALI_TEST_CHECK( !texParameterTrace.FindMethodAndParams("TexParameteri", out.str()) );
2526   out.str("");
2527   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_T << ", " << GL_REPEAT;
2528   DALI_TEST_CHECK( !texParameterTrace.FindMethodAndParams("TexParameteri", out.str()) );
2529
2530   // test the uniforms which used to handle the wrap mode
2531   Renderer renderer = actor.GetRendererAt( 0u );
2532   DALI_TEST_CHECK( renderer );
2533
2534   Property::Value pixelAreaValue = renderer.GetProperty( renderer.GetPropertyIndex( "pixelArea" ) );
2535   DALI_TEST_EQUALS( pixelAreaValue.Get<Vector4>(), pixelArea, TEST_LOCATION );
2536   Vector4 pixelAreaUniform;
2537   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "pixelArea", pixelAreaUniform ) );
2538   DALI_TEST_EQUALS( pixelArea, pixelAreaUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2539
2540   Property::Value wrapModeValue = renderer.GetProperty( renderer.GetPropertyIndex( "wrapMode" ) );
2541   Vector2 wrapMode( WrapMode::MIRRORED_REPEAT-1, WrapMode::REPEAT-1 );
2542   DALI_TEST_EQUALS( wrapModeValue.Get<Vector2>(), wrapMode, TEST_LOCATION );
2543   Vector2 wrapModeUniform;
2544   DALI_TEST_CHECK( gl.GetUniformValue<Vector2>( "wrapMode", wrapModeUniform ) );
2545   DALI_TEST_EQUALS( wrapMode, wrapModeUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2546
2547   actor.Unparent( );
2548   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2549
2550   END_TEST;
2551 }