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