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

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