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