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

   1 /*
   2  * Copyright (c) 2021 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   UnparentAndReset(dummy);
1154
1155   END_TEST;
1156 }
1157
1158 int UtcDaliNPatchVisualAuxiliaryImage02(void)
1159 {
1160   ToolkitTestApplication application;
1161   tet_infoline( "Multiple NPatchVisual with aux image coincidentally" );
1162
1163   const Property::Value NPATCH_TEST{
1164     {ImageVisual::Property::URL, TEST_9_PATCH_FILE_NAME},
1165     {DevelImageVisual::Property::AUXILIARY_IMAGE, TEST_AUX_IMAGE}};
1166
1167   ImageView imageView1 = ImageView::New();
1168   imageView1[ImageView::Property::IMAGE] = NPATCH_TEST;
1169   application.GetScene().Add( imageView1 );
1170
1171   ImageView imageView2 = ImageView::New();
1172   imageView2[ImageView::Property::IMAGE] = NPATCH_TEST;
1173   application.GetScene().Add( imageView2 );
1174
1175   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 3 ), true, TEST_LOCATION );
1176
1177   application.SendNotification();
1178   application.Render();
1179
1180   Renderer renderer1 = imageView1.GetRendererAt( 0 );
1181   auto textureSet1 = renderer1.GetTextures();
1182
1183   Renderer renderer2 = imageView2.GetRendererAt( 0 );
1184   auto textureSet2 = renderer2.GetTextures();
1185   DALI_TEST_EQUALS( textureSet1 != textureSet2, true, TEST_LOCATION );
1186
1187   END_TEST;
1188 }
1189
1190
1191 int UtcDaliVisualFactoryGetNPatchVisualN1(void)
1192 {
1193   //This should still load but display an error image
1194
1195   ToolkitTestApplication application;
1196   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisualN: Request n-patch visual with an invalid image url" );
1197
1198   VisualFactory factory = VisualFactory::Get();
1199   DALI_TEST_CHECK( factory );
1200
1201   Visual::Base visual = factory.CreateVisual( "ERROR.9.jpg", ImageDimensions() );
1202   DALI_TEST_CHECK( visual );
1203
1204   TestGlAbstraction& gl = application.GetGlAbstraction();
1205   TraceCallStack& textureTrace = gl.GetTextureTrace();
1206   textureTrace.Enable(true);
1207
1208   {
1209     DummyControl actor = DummyControl::New(true);
1210     TestVisualAsynchronousRender( application, actor, visual );
1211
1212     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1213     UnparentAndReset(actor);
1214   }
1215
1216   END_TEST;
1217 }
1218
1219 int UtcDaliVisualFactoryGetNPatchVisualN2(void)
1220 {
1221   //This should still load but display an error image
1222
1223   ToolkitTestApplication application;
1224   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisualN: Request n-patch visual with an invalid URL" );
1225
1226   VisualFactory factory = VisualFactory::Get();
1227   DALI_TEST_CHECK( factory );
1228
1229   Property::Map propertyMap;
1230   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::N_PATCH );
1231   propertyMap.Insert( ImageVisual::Property::URL,  "ERROR.9.jpg" );
1232
1233   Visual::Base visual = factory.CreateVisual( propertyMap );
1234   DALI_TEST_CHECK( visual );
1235
1236   TestGlAbstraction& gl = application.GetGlAbstraction();
1237   TraceCallStack& textureTrace = gl.GetTextureTrace();
1238   textureTrace.Enable(true);
1239   TraceCallStack& drawTrace = gl.GetDrawTrace();
1240   drawTrace.Enable(true);
1241
1242   DummyControl actor = DummyControl::New(true);
1243   TestVisualAsynchronousRender( application, actor, visual );
1244
1245   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1246
1247   END_TEST;
1248 }
1249
1250 int UtcDaliVisualFactoryGetNPatchVisualN3(void)
1251 {
1252   // Passing in an invalid visual type so we should not get a visual
1253
1254   ToolkitTestApplication application;
1255   tet_infoline( "UtcDaliVisualFactoryGetNPatchVisualN: Request n-patch visual with an invalid visual type" );
1256
1257   VisualFactory factory = VisualFactory::Get();
1258   DALI_TEST_CHECK( factory );
1259
1260   Property::Map propertyMap;
1261   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  111 );
1262   propertyMap.Insert( ImageVisual::Property::URL,  "ERROR.9.jpg" );
1263
1264   Visual::Base visual = factory.CreateVisual( propertyMap );
1265   DALI_TEST_CHECK( !visual );
1266
1267   END_TEST;
1268 }
1269
1270 int UtcDaliVisualFactoryGetSvgVisual(void)
1271 {
1272   ToolkitTestApplication application;
1273   tet_infoline( "UtcDaliVisualFactoryGetSvgVisual: Request svg visual with a svg url" );
1274
1275   VisualFactory factory = VisualFactory::Get();
1276   Visual::Base visual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions() );
1277   DALI_TEST_CHECK( visual );
1278
1279   TestGlAbstraction& gl = application.GetGlAbstraction();
1280   TraceCallStack& textureTrace = gl.GetTextureTrace();
1281   textureTrace.Enable(true);
1282
1283   DummyControl actor = DummyControl::New(true);
1284   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1285   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1286   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1287   application.GetScene().Add( actor );
1288   visual.SetTransformAndSize(DefaultTransform(), Vector2(200.f, 200.f) );
1289
1290   // Either application.SendNotification() or the trigger can now complete the task.
1291   application.SendNotification();
1292   application.Render();
1293   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1294
1295   // renderer is added to actor
1296   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1297
1298   // waiting for the resource uploading
1299   application.SendNotification();
1300   application.Render();
1301
1302   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1303
1304   END_TEST;
1305 }
1306
1307 int UtcDaliVisualFactoryGetSvgVisualLarge(void)
1308 {
1309   ToolkitTestApplication application;
1310   tet_infoline( "UtcDaliVisualFactoryGetSvgVisual: Request svg visual with a svg url" );
1311
1312   VisualFactory factory = VisualFactory::Get();
1313   Visual::Base visual = factory.CreateVisual( TEST_SVG_FILE_NAME, ImageDimensions( 2000, 2000 ) );
1314   DALI_TEST_CHECK( visual );
1315
1316   TestGlAbstraction& gl = application.GetGlAbstraction();
1317   TraceCallStack& textureTrace = gl.GetTextureTrace();
1318   textureTrace.Enable(true);
1319
1320   DummyControl actor = DummyControl::New(true);
1321   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1322   actor.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS ); // Only rasterizes when it knows control size.
1323   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1324   application.GetScene().Add( actor );
1325
1326   // Either application.SendNotification() or the trigger can now complete the task.
1327   application.SendNotification();
1328   application.Render();
1329   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1330
1331   // renderer is added to actor
1332   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1333
1334   // waiting for the resource uploading
1335   application.SendNotification();
1336   application.Render();
1337
1338   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1339
1340   END_TEST;
1341 }
1342
1343 int UtcDaliVisualFactoryGetSvgVisualAtlas(void)
1344 {
1345   ToolkitTestApplication application;
1346   tet_infoline( "UtcDaliVisualFactoryGetSvgVisual: Request svg visual with enabled atlas" );
1347
1348   VisualFactory factory = VisualFactory::Get();
1349
1350   Property::Map propertyMap;
1351   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::SVG );
1352   propertyMap.Insert( ImageVisual::Property::URL, TEST_SVG_FILE_NAME );
1353   propertyMap.Insert( ImageVisual::Property::ATLASING, true );
1354
1355   Visual::Base visual = factory.CreateVisual( propertyMap );
1356   DALI_TEST_CHECK( visual );
1357
1358   TestGlAbstraction& gl = application.GetGlAbstraction();
1359   TraceCallStack& textureTrace = gl.GetTextureTrace();
1360   textureTrace.Enable(true);
1361
1362   DummyControl actor = DummyControl::New(true);
1363   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1364   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1365   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1366   application.GetScene().Add( actor );
1367   visual.SetTransformAndSize(DefaultTransform(), Vector2(200.f, 200.f) );
1368
1369   // Either application.SendNotification() or the trigger can now complete the task.
1370   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1371   application.SendNotification();
1372   application.Render();
1373   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
1374
1375   // renderer is added to actor
1376   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1377
1378   // waiting for the resource uploading
1379   application.SendNotification();
1380   application.Render();
1381
1382   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
1383
1384   END_TEST;
1385 }
1386
1387 //Creates a mesh visual from the given propertyMap and tries to load it on stage in the given application.
1388 //This is expected to succeed, which will then pass the test.
1389 void MeshVisualLoadsCorrectlyTest( Property::Map& propertyMap, ToolkitTestApplication& application )
1390 {
1391   VisualFactory factory = VisualFactory::Get();
1392   DALI_TEST_CHECK( factory );
1393
1394   //Create a mesh visual.
1395   Visual::Base visual = factory.CreateVisual( propertyMap );
1396   DALI_TEST_CHECK( visual );
1397
1398   //Create an actor on stage to house the visual.
1399   DummyControl actor = DummyControl::New(true);
1400   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1401   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1402   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1403   application.GetScene().Add( actor );
1404   visual.SetTransformAndSize(DefaultTransform(), Vector2( 200.f, 200.f ) );
1405
1406   //Ensure set on stage.
1407   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1408
1409   //Attempt to render to queue resource load requests.
1410   application.SendNotification();
1411   application.Render( 0 );
1412
1413   //Render again to upload the now-loaded textures.
1414   application.SendNotification();
1415   application.Render( 0 );
1416
1417   Matrix testScaleMatrix;
1418   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1419   Matrix actualScaleMatrix;
1420
1421   //Test to see if the object has been successfully loaded.
1422   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1423   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1424
1425   //Finish by setting off stage, and ensuring this was successful.
1426   actor.Unparent();
1427   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1428 }
1429
1430 //Creates a mesh visual from the given propertyMap and tries to load it on stage in the given application.
1431 //This is expected to fail, which will then pass the test.
1432 void MeshVisualDoesNotLoadCorrectlyTest( Property::Map& propertyMap, ToolkitTestApplication& application )
1433 {
1434   VisualFactory factory = VisualFactory::Get();
1435   DALI_TEST_CHECK( factory );
1436
1437   //Create a mesh visual.
1438   Visual::Base visual = factory.CreateVisual( propertyMap );
1439   DALI_TEST_CHECK( visual );
1440
1441   //Create an actor on stage to house the visual.
1442   DummyControl actor = DummyControl::New(true);
1443   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1444   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1445   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1446   application.GetScene().Add( actor );
1447   visual.SetTransformAndSize(DefaultTransform(),  Vector2( 200.f, 200.f ) );
1448
1449   //Ensure set on stage.
1450   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1451
1452   //Attempt to render to queue resource load requests.
1453   application.SendNotification();
1454   application.Render( 0 );
1455
1456   //Render again to upload the now-loaded textures.
1457   application.SendNotification();
1458   application.Render( 0 );
1459
1460   //Test to see if the object has not been loaded, as expected.
1461   Matrix scaleMatrix;
1462   DALI_TEST_CHECK( !application.GetGlAbstraction().GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1463
1464   //Finish by setting off stage, and ensuring this was successful.
1465   actor.Unparent();
1466   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1467 }
1468
1469 //Test if mesh loads correctly when supplied with only the bare minimum requirements, an object file.
1470 int UtcDaliVisualFactoryGetMeshVisual1(void)
1471 {
1472   //Set up test application first, so everything else can be handled.
1473   ToolkitTestApplication application;
1474
1475   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual1:  Request mesh visual with a valid object file only" );
1476
1477   static std::vector<UniformData> customUniforms =
1478   {
1479     UniformData("uObjectMatrix", Property::Type::MATRIX),
1480   };
1481
1482   TestGraphicsController& graphics = application.GetGraphicsController();
1483   graphics.AddCustomUniforms(customUniforms);
1484
1485   //Set up visual properties.
1486   Property::Map propertyMap;
1487   propertyMap.Insert( Toolkit::Visual::Property::TYPE,  Visual::MESH );
1488   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1489
1490   //Test to see if mesh loads correctly.
1491   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1492
1493   END_TEST;
1494 }
1495
1496
1497 //Test if mesh loads correctly when supplied with an object file as well as a blank material file and images directory.
1498 int UtcDaliVisualFactoryGetMeshVisual2(void)
1499 {
1500   //Set up test application first, so everything else can be handled.
1501   ToolkitTestApplication application;
1502
1503   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual2:  Request mesh visual with blank material file and images directory" );
1504
1505   static std::vector<UniformData> customUniforms =
1506   {
1507     UniformData("uObjectMatrix", Property::Type::MATRIX),
1508   };
1509
1510   TestGraphicsController& graphics = application.GetGraphicsController();
1511   graphics.AddCustomUniforms(customUniforms);
1512
1513   //Set up visual properties.
1514   Property::Map propertyMap;
1515   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1516   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1517   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, "" );
1518   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, "" );
1519
1520   //Test to see if mesh loads correctly.
1521   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1522
1523   END_TEST;
1524 }
1525
1526 //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
1527 int UtcDaliVisualFactoryGetMeshVisual3b(void)
1528 {
1529   //Set up test application first, so everything else can be handled.
1530   ToolkitTestApplication application;
1531
1532   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual3:  Request mesh visual with all parameters correct" );
1533
1534   static std::vector<UniformData> customUniforms =
1535   {
1536     UniformData("uObjectMatrix", Property::Type::MATRIX),
1537   };
1538
1539   TestGraphicsController& graphics = application.GetGraphicsController();
1540   graphics.AddCustomUniforms(customUniforms);
1541
1542   //Set up visual properties.
1543   Property::Map propertyMap;
1544   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1545   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1546   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1547   propertyMap.Insert( MeshVisual::Property::USE_MIPMAPPING, Color::GREEN ); // Test that wrong property types don't prevent the object load
1548   propertyMap.Insert( MeshVisual::Property::USE_SOFT_NORMALS, 1.0f );
1549   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, 1.0f );
1550   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1551
1552   //Test to see if mesh loads correctly.
1553   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1554
1555   END_TEST;
1556 }
1557
1558 //Test if mesh loads correctly when supplied with all main parameters, an object file, a material file and a directory location.
1559 int UtcDaliVisualFactoryGetMeshVisual3(void)
1560 {
1561   //Set up test application first, so everything else can be handled.
1562   ToolkitTestApplication application;
1563
1564   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual3:  Request mesh visual with all parameters correct" );
1565
1566   static std::vector<UniformData> customUniforms =
1567   {
1568     UniformData("uObjectMatrix", Property::Type::MATRIX),
1569   };
1570
1571   TestGraphicsController& graphics = application.GetGraphicsController();
1572   graphics.AddCustomUniforms(customUniforms);
1573
1574   //Set up visual properties.
1575   Property::Map propertyMap;
1576   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1577   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1578   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1579   propertyMap.Insert( MeshVisual::Property::USE_MIPMAPPING, false );
1580   propertyMap.Insert( MeshVisual::Property::USE_SOFT_NORMALS, false );
1581   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3::XAXIS );
1582   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1583
1584   //Test to see if mesh loads correctly.
1585   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1586
1587   END_TEST;
1588 }
1589
1590 //Test if mesh visual can load a correctly supplied mesh without a normal map or gloss map in the material file.
1591 int UtcDaliVisualFactoryGetMeshVisual4(void)
1592 {
1593   //Set up test application first, so everything else can be handled.
1594   ToolkitTestApplication application;
1595
1596   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual4:  Request mesh visual with diffuse texture but not normal or gloss." );
1597
1598   static std::vector<UniformData> customUniforms =
1599   {
1600     UniformData("uObjectMatrix", Property::Type::MATRIX),
1601   };
1602
1603   TestGraphicsController& graphics = application.GetGraphicsController();
1604   graphics.AddCustomUniforms(customUniforms);
1605
1606   //Set up visual properties.
1607   Property::Map propertyMap;
1608   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1609   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1610   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_SIMPLE_MTL_FILE_NAME );
1611   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1612
1613   //Test to see if mesh loads correctly.
1614   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1615
1616   END_TEST;
1617 }
1618
1619 //Test if mesh visual can load when made to use diffuse textures only.
1620 int UtcDaliVisualFactoryGetMeshVisual5(void)
1621 {
1622   //Set up test application first, so everything else can be handled.
1623   ToolkitTestApplication application;
1624
1625   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual5:  Request mesh visual and make it only use diffuse textures." );
1626
1627   static std::vector<UniformData> customUniforms =
1628   {
1629     UniformData("uObjectMatrix", Property::Type::MATRIX),
1630   };
1631
1632   TestGraphicsController& graphics = application.GetGraphicsController();
1633   graphics.AddCustomUniforms(customUniforms);
1634
1635   //Set up visual properties.
1636   Property::Map propertyMap;
1637   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1638   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1639   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1640   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1641   propertyMap.Insert( "useMipmapping", false );
1642   propertyMap.Insert( "useSoftNormals", false );
1643   propertyMap.Insert( "lightPosition", Vector3::ZAXIS );
1644   propertyMap.Insert( "shadingMode", MeshVisual::ShadingMode::TEXTURED_WITH_SPECULAR_LIGHTING );
1645
1646   //Test to see if mesh loads correctly.
1647   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1648
1649
1650   END_TEST;
1651 }
1652
1653 //Test if mesh visual can load when made to not use the supplied textures.
1654 int UtcDaliVisualFactoryGetMeshVisual6(void)
1655 {
1656   //Set up test application first, so everything else can be handled.
1657   ToolkitTestApplication application;
1658
1659   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual6:  Request mesh visual and make it not use any textures." );
1660
1661   static std::vector<UniformData> customUniforms =
1662   {
1663     UniformData("uObjectMatrix", Property::Type::MATRIX),
1664   };
1665
1666   TestGraphicsController& graphics = application.GetGraphicsController();
1667   graphics.AddCustomUniforms(customUniforms);
1668
1669   //Set up visual properties.
1670   Property::Map propertyMap;
1671   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1672   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1673   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1674   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1675   propertyMap.Insert( MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING );
1676
1677   //Test to see if mesh loads correctly.
1678   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1679
1680   END_TEST;
1681 }
1682 //Test if mesh visual loads correctly when light position is manually set.
1683 int UtcDaliVisualFactoryGetMeshVisual7(void)
1684 {
1685   //Set up test application first, so everything else can be handled.
1686   ToolkitTestApplication application;
1687
1688   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual7:  Request mesh visual with custom light position." );
1689
1690   static std::vector<UniformData> customUniforms =
1691   {
1692     UniformData("uObjectMatrix", Property::Type::MATRIX),
1693   };
1694
1695   TestGraphicsController& graphics = application.GetGraphicsController();
1696   graphics.AddCustomUniforms(customUniforms);
1697
1698   //Set up visual properties.
1699   Property::Map propertyMap;
1700   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1701   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1702   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1703   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1704   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 0.0, 1.0, 2.0 ) );
1705
1706   //Test to see if mesh loads correctly.
1707   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1708
1709   END_TEST;
1710 }
1711
1712 //Test if mesh visual loads correctly when supplied an object file without face normals or texture points.
1713 //Note that this notably tests object loader functionality.
1714 int UtcDaliVisualFactoryGetMeshVisual8(void)
1715 {
1716   //Set up test application first, so everything else can be handled.
1717   ToolkitTestApplication application;
1718
1719   tet_infoline( "UtcDaliVisualFactoryGetMeshVisual5:  Request mesh visual with normal-less object file." );
1720
1721   static std::vector<UniformData> customUniforms =
1722   {
1723     UniformData("uObjectMatrix", Property::Type::MATRIX),
1724   };
1725
1726   TestGraphicsController& graphics = application.GetGraphicsController();
1727   graphics.AddCustomUniforms(customUniforms);
1728
1729   //Set up visual properties.
1730   Property::Map propertyMap;
1731   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1732   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_SIMPLE_OBJ_FILE_NAME );
1733   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1734   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1735
1736   //Test to see if mesh loads correctly.
1737   MeshVisualLoadsCorrectlyTest( propertyMap, application );
1738
1739   END_TEST;
1740 }
1741
1742 //Test if mesh visual handles the case of lacking an object file.
1743 int UtcDaliVisualFactoryGetMeshVisualN1(void)
1744 {
1745   //Set up test application first, so everything else can be handled.
1746   ToolkitTestApplication application;
1747
1748   tet_infoline( "UtcDaliVisualFactoryGetMeshVisualN1:  Request mesh visual without object file" );
1749
1750   //Set up visual properties.
1751   Property::Map propertyMap;
1752   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1753   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1754   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1755
1756   //Test to see if mesh doesn't load with these properties, as expected.
1757   MeshVisualDoesNotLoadCorrectlyTest( propertyMap, application );
1758
1759
1760   END_TEST;
1761 }
1762
1763 //Test if mesh visual handles the case of being passed invalid material and images urls.
1764 int UtcDaliVisualFactoryGetMeshVisualN2(void)
1765 {
1766   //Set up test application first, so everything else can be handled.
1767   ToolkitTestApplication application;
1768
1769   tet_infoline( "UtcDaliVisualFactoryGetMeshVisualN2:  Request mesh visual with invalid material and images urls" );
1770
1771   //Set up visual properties.
1772   Property::Map propertyMap;
1773   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1774   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME );
1775   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, "invalid" );
1776   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, "also invalid" );
1777
1778   //Test to see if mesh doesn't load with these properties, as expected.
1779   MeshVisualDoesNotLoadCorrectlyTest( propertyMap, application );
1780
1781
1782   END_TEST;
1783 }
1784
1785 //Test if mesh visual handles the case of being passed an invalid object url
1786 int UtcDaliVisualFactoryGetMeshVisualN3(void)
1787 {
1788   //Set up test application first, so everything else can be handled.
1789   ToolkitTestApplication application;
1790   tet_infoline( "UtcDaliVisualFactoryGetMeshVisualN3:  Request mesh visual with invalid object url" );
1791
1792
1793   //Set up visual properties.
1794   Property::Map propertyMap;
1795   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::MESH );
1796   propertyMap.Insert( MeshVisual::Property::OBJECT_URL, "invalid" );
1797   propertyMap.Insert( MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME );
1798   propertyMap.Insert( MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/" );
1799
1800   //Test to see if mesh doesn't load with these properties, as expected.
1801   MeshVisualDoesNotLoadCorrectlyTest( propertyMap, application );
1802
1803   END_TEST;
1804 }
1805
1806 //Creates a primitive visual with the given property map and tests to see if it correctly loads in the given application.
1807 void TestPrimitiveVisualWithProperties( Property::Map& propertyMap, ToolkitTestApplication& application )
1808 {
1809   VisualFactory factory = VisualFactory::Get();
1810   DALI_TEST_CHECK( factory );
1811
1812   //Create a primitive visual.
1813   Visual::Base visual = factory.CreateVisual( propertyMap );
1814   DALI_TEST_CHECK( visual );
1815
1816   //Create an actor on stage to house the visual.
1817   DummyControl actor = DummyControl::New(true);
1818   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1819   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
1820
1821   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
1822   application.GetScene().Add( actor );
1823   visual.SetTransformAndSize(DefaultTransform(),  Vector2( 200.f, 200.f ) );
1824
1825   //Ensure set on stage.
1826   DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
1827
1828   //Tell test application to load the visual.
1829   application.SendNotification();
1830   application.Render(0);
1831
1832   Matrix testScaleMatrix;
1833   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1834   Matrix actualScaleMatrix;
1835
1836   //Test to see if the object has been successfully loaded.
1837   DALI_TEST_CHECK( application.GetGlAbstraction().GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1838   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1839
1840   //Finish by setting off stage, and ensuring this was successful.
1841   actor.Unparent();
1842   DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
1843 }
1844
1845 //Test if primitive shape loads correctly when supplied with only the bare minimum requirements, the shape to use.
1846 int UtcDaliVisualFactoryGetPrimitiveVisual1(void)
1847 {
1848   //Set up test application first, so everything else can be handled.
1849   ToolkitTestApplication application;
1850
1851   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual1:  Request primitive visual with a shape only" );
1852
1853   static std::vector<UniformData> customUniforms =
1854   {
1855     UniformData("uObjectMatrix", Property::Type::MATRIX),
1856   };
1857
1858   TestGraphicsController& graphics = application.GetGraphicsController();
1859   graphics.AddCustomUniforms(customUniforms);
1860
1861   //Set up visual properties.
1862   Property::Map propertyMap;
1863   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1864   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
1865
1866   //Test to see if shape loads correctly.
1867   TestPrimitiveVisualWithProperties( propertyMap, application );
1868
1869   END_TEST;
1870 }
1871
1872 //Test if primitive shape loads correctly when supplied with all possible parameters
1873 int UtcDaliVisualFactoryGetPrimitiveVisual2(void)
1874 {
1875   //Set up test application first, so everything else can be handled.
1876   ToolkitTestApplication application;
1877
1878   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual2:  Request primitive visual with everything" );
1879
1880   static std::vector<UniformData> customUniforms =
1881   {
1882     UniformData("uObjectMatrix", Property::Type::MATRIX),
1883   };
1884
1885   TestGraphicsController& graphics = application.GetGraphicsController();
1886   graphics.AddCustomUniforms(customUniforms);
1887
1888   //Set up visual properties.
1889   Property::Map propertyMap;
1890   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1891   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE );
1892   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1893   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
1894   propertyMap.Insert( PrimitiveVisual::Property::STACKS, 20 );
1895   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
1896   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
1897   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
1898   propertyMap.Insert( PrimitiveVisual::Property::SCALE_RADIUS, 60.0f );
1899   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.7f );
1900   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.8f );
1901   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 0.9, 1.0, 1.1 ) );
1902
1903   //Test to see if shape loads correctly.
1904   TestPrimitiveVisualWithProperties( propertyMap, application );
1905
1906   END_TEST;
1907 }
1908
1909 //Test if primitive shape loads a sphere correctly.
1910 int UtcDaliVisualFactoryGetPrimitiveVisual3(void)
1911 {
1912   //Set up test application first, so everything else can be handled.
1913   ToolkitTestApplication application;
1914
1915   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual3:  Request primitive visual to display a sphere" );
1916
1917   static std::vector<UniformData> customUniforms =
1918   {
1919     UniformData("uObjectMatrix", Property::Type::MATRIX),
1920   };
1921
1922   TestGraphicsController& graphics = application.GetGraphicsController();
1923   graphics.AddCustomUniforms(customUniforms);
1924
1925   //Set up visual properties.
1926   Property::Map propertyMap;
1927   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1928   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
1929   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1930   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
1931   propertyMap.Insert( PrimitiveVisual::Property::STACKS, 20 );
1932
1933   //Test to see if shape loads correctly.
1934   TestPrimitiveVisualWithProperties( propertyMap, application );
1935
1936   END_TEST;
1937 }
1938
1939 //Test if primitive shape loads a conic section correctly.
1940 int UtcDaliVisualFactoryGetPrimitiveVisual4(void)
1941 {
1942   //Set up test application first, so everything else can be handled.
1943   ToolkitTestApplication application;
1944
1945   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual4:  Request primitive visual to display a conic section" );
1946
1947   static std::vector<UniformData> customUniforms =
1948   {
1949     UniformData("uObjectMatrix", Property::Type::MATRIX),
1950   };
1951
1952   TestGraphicsController& graphics = application.GetGraphicsController();
1953   graphics.AddCustomUniforms(customUniforms);
1954
1955   //Set up visual properties.
1956   Property::Map propertyMap;
1957   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1958   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CONICAL_FRUSTUM );
1959   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1960   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
1961   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
1962   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
1963   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
1964
1965   //Test to see if shape loads correctly.
1966   TestPrimitiveVisualWithProperties( propertyMap, application );
1967
1968   END_TEST;
1969 }
1970
1971 //Test if primitive shape loads a bevelled cube correctly.
1972 int UtcDaliVisualFactoryGetPrimitiveVisual5(void)
1973 {
1974   //Set up test application first, so everything else can be handled.
1975   ToolkitTestApplication application;
1976
1977   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual5:  Request primitive visual to display a bevelled cube" );
1978
1979   static std::vector<UniformData> customUniforms =
1980   {
1981     UniformData("uObjectMatrix", Property::Type::MATRIX),
1982   };
1983
1984   TestGraphicsController& graphics = application.GetGraphicsController();
1985   graphics.AddCustomUniforms(customUniforms);
1986
1987   //Set up visual properties.
1988   Property::Map propertyMap;
1989   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
1990   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::BEVELLED_CUBE );
1991   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
1992   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.7f );
1993
1994   //Test to see if shape loads correctly.
1995   TestPrimitiveVisualWithProperties( propertyMap, application );
1996
1997   END_TEST;
1998 }
1999
2000 //Test if primitive shape loads an octahedron correctly.
2001 int UtcDaliVisualFactoryGetPrimitiveVisual6(void)
2002 {
2003   //Set up test application first, so everything else can be handled.
2004   ToolkitTestApplication application;
2005
2006   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual6:  Request primitive visual to display an octahedron" );
2007
2008   static std::vector<UniformData> customUniforms =
2009   {
2010     UniformData("uObjectMatrix", Property::Type::MATRIX),
2011   };
2012
2013   TestGraphicsController& graphics = application.GetGraphicsController();
2014   graphics.AddCustomUniforms(customUniforms);
2015
2016   //Set up visual properties.
2017   Property::Map propertyMap;
2018   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2019   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::OCTAHEDRON );
2020   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
2021
2022   //Test to see if shape loads correctly.
2023   TestPrimitiveVisualWithProperties( propertyMap, application );
2024
2025   END_TEST;
2026 }
2027
2028 //Test if primitive shape loads a cone correctly.
2029 int UtcDaliVisualFactoryGetPrimitiveVisual7(void)
2030 {
2031   //Set up test application first, so everything else can be handled.
2032   ToolkitTestApplication application;
2033
2034   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual7:  Request primitive visual to display a cone" );
2035
2036   static std::vector<UniformData> customUniforms =
2037   {
2038     UniformData("uObjectMatrix", Property::Type::MATRIX),
2039   };
2040
2041   TestGraphicsController& graphics = application.GetGraphicsController();
2042   graphics.AddCustomUniforms(customUniforms);
2043
2044   //Set up visual properties.
2045   Property::Map propertyMap;
2046   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2047   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CONE );
2048   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
2049   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
2050   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
2051   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
2052
2053   //Test to see if shape loads correctly.
2054   TestPrimitiveVisualWithProperties( propertyMap, application );
2055
2056   END_TEST;
2057 }
2058
2059 //Test if primitive shape loads correctly when light position is manually set.
2060 int UtcDaliVisualFactoryGetPrimitiveVisual8(void)
2061 {
2062   //Set up test application first, so everything else can be handled.
2063   ToolkitTestApplication application;
2064
2065   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual8:  Request primitive visual with set light position" );
2066
2067   static std::vector<UniformData> customUniforms =
2068   {
2069     UniformData("uObjectMatrix", Property::Type::MATRIX),
2070   };
2071
2072   TestGraphicsController& graphics = application.GetGraphicsController();
2073   graphics.AddCustomUniforms(customUniforms);
2074
2075   //Set up visual properties.
2076   Property::Map propertyMap;
2077   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2078   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2079   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
2080   propertyMap.Insert( MeshVisual::Property::LIGHT_POSITION, Vector3( 0.0, 1.0, 2.0 ) );
2081
2082   //Test to see if shape loads correctly.
2083   TestPrimitiveVisualWithProperties( propertyMap, application );
2084
2085   END_TEST;
2086 }
2087
2088 //Test if primitive shape loads correctly when told to use too many slices.
2089 int UtcDaliVisualFactoryGetPrimitiveVisual9(void)
2090 {
2091   //Set up test application first, so everything else can be handled.
2092   ToolkitTestApplication application;
2093
2094   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual9:  Request primitive visual with above-cap slices." );
2095
2096   static std::vector<UniformData> customUniforms =
2097   {
2098     UniformData("uObjectMatrix", Property::Type::MATRIX),
2099   };
2100
2101   TestGraphicsController& graphics = application.GetGraphicsController();
2102   graphics.AddCustomUniforms(customUniforms);
2103
2104   //Set up visual properties.
2105   Property::Map propertyMap;
2106   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2107   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2108   propertyMap.Insert( PrimitiveVisual::Property::SLICES, Property::Value( 1000000 ) );
2109
2110   //Test to see if shape loads correctly.
2111   TestPrimitiveVisualWithProperties( propertyMap, application );
2112
2113   END_TEST;
2114 }
2115
2116 //Test if primitive shape loads correctly when told to use too few slices. (2 slices or less.)
2117 int UtcDaliVisualFactoryGetPrimitiveVisual10(void)
2118 {
2119   //Set up test application first, so everything else can be handled.
2120   ToolkitTestApplication application;
2121
2122   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual10:  Request primitive visual with too few slices." );
2123
2124   static std::vector<UniformData> customUniforms =
2125   {
2126     UniformData("uObjectMatrix", Property::Type::MATRIX),
2127   };
2128
2129   TestGraphicsController& graphics = application.GetGraphicsController();
2130   graphics.AddCustomUniforms(customUniforms);
2131
2132   //Set up visual properties.
2133   Property::Map propertyMap;
2134   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2135   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2136   propertyMap.Insert( PrimitiveVisual::Property::SLICES, Property::Value( 2 ) );
2137
2138   //Test to see if shape loads correctly.
2139   TestPrimitiveVisualWithProperties( propertyMap, application );
2140
2141   END_TEST;
2142 }
2143
2144 //Test if primitive shape loads correctly when told to use too many stacks.
2145 int UtcDaliVisualFactoryGetPrimitiveVisual11(void)
2146 {
2147   //Set up test application first, so everything else can be handled.
2148   ToolkitTestApplication application;
2149
2150   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual11:  Request primitive visual with too many stacks." );
2151
2152   static std::vector<UniformData> customUniforms =
2153   {
2154     UniformData("uObjectMatrix", Property::Type::MATRIX),
2155   };
2156
2157   TestGraphicsController& graphics = application.GetGraphicsController();
2158   graphics.AddCustomUniforms(customUniforms);
2159
2160   //Set up visual properties.
2161   Property::Map propertyMap;
2162   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2163   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2164   propertyMap.Insert( PrimitiveVisual::Property::STACKS, Property::Value( 1000000 ) );
2165
2166   //Test to see if shape loads correctly.
2167   TestPrimitiveVisualWithProperties( propertyMap, application );
2168
2169   END_TEST;
2170 }
2171
2172 //Test if primitive shape loads correctly when told to use too few stacks. (1 stack or less.)
2173 int UtcDaliVisualFactoryGetPrimitiveVisual12(void)
2174 {
2175   //Set up test application first, so everything else can be handled.
2176   ToolkitTestApplication application;
2177
2178   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual12:  Request primitive visual with too few stacks." );
2179
2180   static std::vector<UniformData> customUniforms =
2181   {
2182     UniformData("uObjectMatrix", Property::Type::MATRIX),
2183   };
2184
2185   TestGraphicsController& graphics = application.GetGraphicsController();
2186   graphics.AddCustomUniforms(customUniforms);
2187
2188   //Set up visual properties.
2189   Property::Map propertyMap;
2190   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2191   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2192   propertyMap.Insert( PrimitiveVisual::Property::STACKS, Property::Value( 1 ) );
2193
2194   //Test to see if shape loads correctly.
2195   TestPrimitiveVisualWithProperties( propertyMap, application );
2196
2197   END_TEST;
2198 }
2199
2200 //Test if primitive shape loads correctly when told to use invalid (zero or negative) dimensions.
2201 int UtcDaliVisualFactoryGetPrimitiveVisual13(void)
2202 {
2203   //Set up test application first, so everything else can be handled.
2204   ToolkitTestApplication application;
2205
2206   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual13:  Request primitive visual with invalid scale dimensions." );
2207
2208   static std::vector<UniformData> customUniforms =
2209   {
2210     UniformData("uObjectMatrix", Property::Type::MATRIX),
2211   };
2212
2213   TestGraphicsController& graphics = application.GetGraphicsController();
2214   graphics.AddCustomUniforms(customUniforms);
2215
2216   //Set up visual properties.
2217   Property::Map propertyMap;
2218   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2219   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2220   propertyMap.Insert( PrimitiveVisual::Property::SCALE_DIMENSIONS, Vector3::ZERO );
2221
2222   //Test to see if shape loads correctly.
2223   TestPrimitiveVisualWithProperties( propertyMap, application );
2224
2225   END_TEST;
2226 }
2227
2228 //Test if primitive shape loads correctly when told to use too low a bevel percentage.
2229 int UtcDaliVisualFactoryGetPrimitiveVisual14(void)
2230 {
2231   //Set up test application first, so everything else can be handled.
2232   ToolkitTestApplication application;
2233
2234   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual14:  Request primitive visual with too low a bevel percentage." );
2235
2236   static std::vector<UniformData> customUniforms =
2237   {
2238     UniformData("uObjectMatrix", Property::Type::MATRIX),
2239   };
2240
2241   TestGraphicsController& graphics = application.GetGraphicsController();
2242   graphics.AddCustomUniforms(customUniforms);
2243
2244   //Set up visual properties.
2245   Property::Map propertyMap;
2246   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2247   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2248   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::Value( -1.0f ) );
2249
2250   //Test to see if shape loads correctly.
2251   TestPrimitiveVisualWithProperties( propertyMap, application );
2252
2253   END_TEST;
2254 }
2255
2256 //Test if primitive shape loads correctly when told to use too high a bevel percentage.
2257 int UtcDaliVisualFactoryGetPrimitiveVisual15(void)
2258 {
2259   //Set up test application first, so everything else can be handled.
2260   ToolkitTestApplication application;
2261
2262   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual15:  Request primitive visual with too high a bevel percentage." );
2263
2264   static std::vector<UniformData> customUniforms =
2265   {
2266     UniformData("uObjectMatrix", Property::Type::MATRIX),
2267   };
2268
2269   TestGraphicsController& graphics = application.GetGraphicsController();
2270   graphics.AddCustomUniforms(customUniforms);
2271
2272   //Set up visual properties.
2273   Property::Map propertyMap;
2274   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2275   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2276   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::Value( 2.0f ) );
2277
2278   //Test to see if shape loads correctly.
2279   TestPrimitiveVisualWithProperties( propertyMap, application );
2280
2281   END_TEST;
2282 }
2283
2284 //Test if primitive shape loads correctly when told to use too low a bevel smoothness.
2285 int UtcDaliVisualFactoryGetPrimitiveVisual16(void)
2286 {
2287   //Set up test application first, so everything else can be handled.
2288   ToolkitTestApplication application;
2289
2290   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual16:  Request primitive visual with too low a bevel smoothness." );
2291
2292   static std::vector<UniformData> customUniforms =
2293   {
2294     UniformData("uObjectMatrix", Property::Type::MATRIX),
2295   };
2296
2297   TestGraphicsController& graphics = application.GetGraphicsController();
2298   graphics.AddCustomUniforms(customUniforms);
2299
2300   //Set up visual properties.
2301   Property::Map propertyMap;
2302   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2303   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2304   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::Value( -1.0f ) );
2305
2306   //Test to see if shape loads correctly.
2307   TestPrimitiveVisualWithProperties( propertyMap, application );
2308
2309   END_TEST;
2310 }
2311
2312 //Test if primitive shape loads correctly when told to use too high a bevel smoothness.
2313 int UtcDaliVisualFactoryGetPrimitiveVisual17(void)
2314 {
2315   //Set up test application first, so everything else can be handled.
2316   ToolkitTestApplication application;
2317
2318   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual17:  Request primitive visual with too high a bevel smoothness." );
2319
2320   static std::vector<UniformData> customUniforms =
2321   {
2322     UniformData("uObjectMatrix", Property::Type::MATRIX),
2323   };
2324
2325   TestGraphicsController& graphics = application.GetGraphicsController();
2326   graphics.AddCustomUniforms(customUniforms);
2327
2328   //Set up visual properties.
2329   Property::Map propertyMap;
2330   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2331   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE );
2332   propertyMap.Insert( PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::Value( 2.0f ) );
2333
2334   //Test to see if shape loads correctly.
2335   TestPrimitiveVisualWithProperties( propertyMap, application );
2336
2337   END_TEST;
2338 }
2339
2340 //Test if primitive shape loads a conic section correctly.
2341 int UtcDaliVisualFactoryGetPrimitiveVisual18(void)
2342 {
2343   //Set up test application first, so everything else can be handled.
2344   ToolkitTestApplication application;
2345
2346   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisual18:  Request primitive visual to display a conic section" );
2347
2348   static std::vector<UniformData> customUniforms =
2349   {
2350     UniformData("uObjectMatrix", Property::Type::MATRIX),
2351   };
2352
2353   TestGraphicsController& graphics = application.GetGraphicsController();
2354   graphics.AddCustomUniforms(customUniforms);
2355
2356   //Set up visual properties.
2357   Property::Map propertyMap;
2358   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2359   propertyMap.Insert( PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CONICAL_FRUSTUM );
2360   propertyMap.Insert( PrimitiveVisual::Property::MIX_COLOR, Vector4( 0.5, 0.5, 0.5, 1.0 ) );
2361   propertyMap.Insert( PrimitiveVisual::Property::SLICES, 10 );
2362   propertyMap.Insert( PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f );
2363   propertyMap.Insert( PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f );
2364   propertyMap.Insert( PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f );
2365
2366   //Test to see if shape loads correctly.
2367   TestPrimitiveVisualWithProperties( propertyMap, application );
2368
2369   END_TEST;
2370 }
2371
2372 //Test if primitive shape visual handles the case of not being passed a specific shape to use.
2373 int UtcDaliVisualFactoryGetPrimitiveVisualN1(void)
2374 {
2375   //Set up test application first, so everything else can be handled.
2376   ToolkitTestApplication application;
2377
2378   tet_infoline( "UtcDaliVisualFactoryGetPrimitiveVisualN1:  Request primitive visual without shape" );
2379
2380   static std::vector<UniformData> customUniforms =
2381   {
2382     UniformData("uObjectMatrix", Property::Type::MATRIX),
2383   };
2384
2385   TestGraphicsController& graphics = application.GetGraphicsController();
2386   graphics.AddCustomUniforms(customUniforms);
2387
2388   //Set up visual properties, without supplying shape.
2389   Property::Map propertyMap;
2390   propertyMap.Insert( Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE );
2391
2392   //Test to see if shape loads regardless of missing input.
2393   TestPrimitiveVisualWithProperties( propertyMap, application );
2394
2395   END_TEST;
2396 }
2397
2398 int UtcDaliVisualFactoryGetAnimatedImageVisual1(void)
2399 {
2400   ToolkitTestApplication application;
2401   tet_infoline( "UtcDaliVisualFactoryGetAnimatedImageVisual1: Request animated image visual with a gif url" );
2402
2403   TestGlAbstraction& gl = application.GetGlAbstraction();
2404   TraceCallStack& textureTrace = gl.GetTextureTrace();
2405   textureTrace.Enable(true);
2406
2407   VisualFactory factory = VisualFactory::Get();
2408   Visual::Base visual = factory.CreateVisual( TEST_GIF_FILE_NAME, ImageDimensions() );
2409   DALI_TEST_CHECK( visual );
2410
2411   DummyControl actor = DummyControl::New(true);
2412   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
2413   dummyImpl.RegisterVisual( DummyControl::Property::TEST_VISUAL, visual );
2414   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
2415   application.GetScene().Add( actor );
2416
2417   application.SendNotification();
2418   application.Render();
2419
2420   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 2 ), true, TEST_LOCATION );
2421
2422   application.SendNotification();
2423   application.Render();
2424
2425   // renderer is added to actor
2426   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
2427   Renderer renderer = actor.GetRendererAt( 0u );
2428   DALI_TEST_CHECK( renderer );
2429
2430   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2431   textureTrace.Reset();
2432
2433   // Force the timer used by the animatedImageVisual to tick,
2434   Dali::Timer timer = Timer::New( 0 );
2435   timer.MockEmitSignal();
2436   application.SendNotification();
2437   application.Render();
2438
2439   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2440
2441   application.SendNotification();
2442   application.Render();
2443   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2444   textureTrace.Reset();
2445
2446   // Force the timer used by the animatedImageVisual to tick,
2447   timer.MockEmitSignal();
2448   application.SendNotification();
2449   application.Render();
2450
2451   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2452
2453   application.SendNotification();
2454   application.Render();
2455   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2456   textureTrace.Reset();
2457
2458   // Force the timer used by the animatedImageVisual to tick,
2459   timer.MockEmitSignal();
2460   application.SendNotification();
2461   application.Render();
2462
2463   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 1 ), true, TEST_LOCATION );
2464
2465   application.SendNotification();
2466   application.Render();
2467   DALI_TEST_EQUALS( textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION );
2468   textureTrace.Reset();
2469
2470   // Test SetOffScene().
2471   actor.Unparent();
2472   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2473
2474   END_TEST;
2475 }
2476
2477 int UtcDaliVisualFactoryGetAnimatedImageVisual2(void)
2478 {
2479   ToolkitTestApplication application;
2480   tet_infoline( "UtcDaliVisualFactoryGetAnimatedImageVisual2: Request animated image visual with a Property::Map, test custom wrap mode and pixel area" );
2481
2482   static std::vector<UniformData> customUniforms =
2483   {
2484     UniformData("pixelArea", Property::Type::VECTOR4),
2485     UniformData("wrapMode", Property::Type::VECTOR2),
2486   };
2487
2488   TestGraphicsController& graphics = application.GetGraphicsController();
2489   graphics.AddCustomUniforms(customUniforms);
2490
2491   const Vector4 pixelArea(-0.5f, -0.5f, 2.f, 2.f);
2492   Property::Map propertyMap;
2493   propertyMap.Add( Toolkit::Visual::Property::TYPE,  Visual::IMAGE  )
2494              .Add( ImageVisual::Property::URL, TEST_GIF_FILE_NAME  )
2495              .Add( ImageVisual::Property::PIXEL_AREA, pixelArea )
2496              .Add( ImageVisual::Property::WRAP_MODE_U, WrapMode::MIRRORED_REPEAT )
2497              .Add( ImageVisual::Property::WRAP_MODE_V, WrapMode::REPEAT );
2498
2499   Visual::Base visual = VisualFactory::Get().CreateVisual( propertyMap );
2500   DALI_TEST_CHECK( visual );
2501
2502   TestGlAbstraction& gl = application.GetGlAbstraction();
2503   TraceCallStack& textureTrace = gl.GetTextureTrace();
2504   textureTrace.Enable(true);
2505   TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
2506   texParameterTrace.Enable( true );
2507
2508   DummyControl actor = DummyControl::New(true);
2509   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
2510   dummyImpl.RegisterVisual( Control::CONTROL_PROPERTY_END_INDEX + 1, visual );
2511   actor.SetProperty( Actor::Property::SIZE, Vector2( 200.f, 200.f ) );
2512   application.GetScene().Add( actor );
2513
2514   application.SendNotification();
2515   application.Render();
2516
2517   DALI_TEST_EQUALS( Test::WaitForEventThreadTrigger( 2 ), true, TEST_LOCATION );
2518
2519   application.SendNotification();
2520   application.Render();
2521
2522   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
2523
2524   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
2525
2526   // For animated image visual, the wrapping is handled manually in shader, so the following gl function should not be called
2527   std::stringstream out;
2528   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_S << ", " << GL_MIRRORED_REPEAT;
2529   DALI_TEST_CHECK( !texParameterTrace.FindMethodAndParams("TexParameteri", out.str()) );
2530   out.str("");
2531   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_T << ", " << GL_REPEAT;
2532   DALI_TEST_CHECK( !texParameterTrace.FindMethodAndParams("TexParameteri", out.str()) );
2533
2534   // test the uniforms which used to handle the wrap mode
2535   Renderer renderer = actor.GetRendererAt( 0u );
2536   DALI_TEST_CHECK( renderer );
2537
2538   Property::Value pixelAreaValue = renderer.GetProperty( renderer.GetPropertyIndex( "pixelArea" ) );
2539   DALI_TEST_EQUALS( pixelAreaValue.Get<Vector4>(), pixelArea, TEST_LOCATION );
2540   Vector4 pixelAreaUniform;
2541   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "pixelArea", pixelAreaUniform ) );
2542   DALI_TEST_EQUALS( pixelArea, pixelAreaUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2543
2544   Property::Value wrapModeValue = renderer.GetProperty( renderer.GetPropertyIndex( "wrapMode" ) );
2545   Vector2 wrapMode( WrapMode::MIRRORED_REPEAT-1, WrapMode::REPEAT-1 );
2546   DALI_TEST_EQUALS( wrapModeValue.Get<Vector2>(), wrapMode, TEST_LOCATION );
2547   Vector2 wrapModeUniform;
2548   DALI_TEST_CHECK( gl.GetUniformValue<Vector2>( "wrapMode", wrapModeUniform ) );
2549   DALI_TEST_EQUALS( wrapMode, wrapModeUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION );
2550
2551   actor.Unparent( );
2552   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
2553
2554   END_TEST;
2555 }