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

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