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   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1533
1534   // renderer is added to actor
1535   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
1536
1537   // waiting for the resource uploading
1538   application.SendNotification();
1539   application.Render();
1540
1541   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1542
1543   END_TEST;
1544 }
1545
1546 int UtcDaliVisualFactoryGetSvgVisualLarge(void)
1547 {
1548   ToolkitTestApplication application;
1549   tet_infoline("UtcDaliVisualFactoryGetSvgVisual: Request svg visual with a svg url");
1550
1551   VisualFactory factory = VisualFactory::Get();
1552   Visual::Base  visual  = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions(2000, 2000));
1553   DALI_TEST_CHECK(visual);
1554
1555   TestGlAbstraction& gl           = application.GetGlAbstraction();
1556   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1557   textureTrace.Enable(true);
1558
1559   DummyControl      actor     = DummyControl::New(true);
1560   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1561   actor.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS); // Only rasterizes when it knows control size.
1562   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1563   application.GetScene().Add(actor);
1564
1565   // Either application.SendNotification() or the trigger can now complete the task.
1566   application.SendNotification();
1567   application.Render();
1568   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1569
1570   // renderer is added to actor
1571   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
1572
1573   // waiting for the resource uploading
1574   application.SendNotification();
1575   application.Render();
1576
1577   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1578
1579   END_TEST;
1580 }
1581
1582 int UtcDaliVisualFactoryGetSvgVisualAtlas(void)
1583 {
1584   ToolkitTestApplication application;
1585   tet_infoline("UtcDaliVisualFactoryGetSvgVisual: Request svg visual with enabled atlas");
1586
1587   VisualFactory factory = VisualFactory::Get();
1588
1589   Property::Map propertyMap;
1590   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
1591   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
1592   propertyMap.Insert(ImageVisual::Property::ATLASING, true);
1593
1594   Visual::Base visual = factory.CreateVisual(propertyMap);
1595   DALI_TEST_CHECK(visual);
1596
1597   TestGlAbstraction& gl           = application.GetGlAbstraction();
1598   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1599   textureTrace.Enable(true);
1600
1601   DummyControl      actor     = DummyControl::New(true);
1602   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1603   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1604   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1605   application.GetScene().Add(actor);
1606   visual.SetTransformAndSize(DefaultTransform(), Vector2(200.f, 200.f));
1607
1608   // Either application.SendNotification() or the trigger can now complete the task.
1609   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
1610   application.SendNotification();
1611   application.Render();
1612   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1613
1614   // renderer is added to actor
1615   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
1616
1617   // waiting for the resource uploading
1618   application.SendNotification();
1619   application.Render();
1620
1621   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1622
1623   END_TEST;
1624 }
1625
1626 //Creates a mesh visual from the given propertyMap and tries to load it on stage in the given application.
1627 //This is expected to succeed, which will then pass the test.
1628 void MeshVisualLoadsCorrectlyTest(Property::Map& propertyMap, ToolkitTestApplication& application)
1629 {
1630   VisualFactory factory = VisualFactory::Get();
1631   DALI_TEST_CHECK(factory);
1632
1633   //Create a mesh visual.
1634   Visual::Base visual = factory.CreateVisual(propertyMap);
1635   DALI_TEST_CHECK(visual);
1636
1637   //Create an actor on stage to house the visual.
1638   DummyControl      actor     = DummyControl::New(true);
1639   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1640   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1641   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1642   application.GetScene().Add(actor);
1643   visual.SetTransformAndSize(DefaultTransform(), Vector2(200.f, 200.f));
1644
1645   //Ensure set on stage.
1646   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1647
1648   //Attempt to render to queue resource load requests.
1649   application.SendNotification();
1650   application.Render(0);
1651
1652   //Render again to upload the now-loaded textures.
1653   application.SendNotification();
1654   application.Render(0);
1655
1656   Matrix testScaleMatrix;
1657   testScaleMatrix.SetIdentityAndScale(Vector3(1.0, -1.0, 1.0));
1658   Matrix actualScaleMatrix;
1659
1660   //Test to see if the object has been successfully loaded.
1661   DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Matrix>("uObjectMatrix", actualScaleMatrix));
1662   DALI_TEST_EQUALS(actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1663
1664   //Finish by setting off stage, and ensuring this was successful.
1665   actor.Unparent();
1666   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1667 }
1668
1669 //Creates a mesh visual from the given propertyMap and tries to load it on stage in the given application.
1670 //This is expected to fail, which will then pass the test.
1671 void MeshVisualDoesNotLoadCorrectlyTest(Property::Map& propertyMap, ToolkitTestApplication& application)
1672 {
1673   VisualFactory factory = VisualFactory::Get();
1674   DALI_TEST_CHECK(factory);
1675
1676   //Create a mesh visual.
1677   Visual::Base visual = factory.CreateVisual(propertyMap);
1678   DALI_TEST_CHECK(visual);
1679
1680   //Create an actor on stage to house the visual.
1681   DummyControl      actor     = DummyControl::New(true);
1682   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1683   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1684   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1685   application.GetScene().Add(actor);
1686   visual.SetTransformAndSize(DefaultTransform(), Vector2(200.f, 200.f));
1687
1688   //Ensure set on stage.
1689   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1690
1691   //Attempt to render to queue resource load requests.
1692   application.SendNotification();
1693   application.Render(0);
1694
1695   //Render again to upload the now-loaded textures.
1696   application.SendNotification();
1697   application.Render(0);
1698
1699   //Test to see if the object has not been loaded, as expected.
1700   Matrix scaleMatrix;
1701   DALI_TEST_CHECK(!application.GetGlAbstraction().GetUniformValue<Matrix>("uObjectMatrix", scaleMatrix));
1702
1703   //Finish by setting off stage, and ensuring this was successful.
1704   actor.Unparent();
1705   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1706 }
1707
1708 //Test if mesh loads correctly when supplied with only the bare minimum requirements, an object file.
1709 int UtcDaliVisualFactoryGetMeshVisual1(void)
1710 {
1711   //Set up test application first, so everything else can be handled.
1712   ToolkitTestApplication application;
1713
1714   tet_infoline("UtcDaliVisualFactoryGetMeshVisual1:  Request mesh visual with a valid object file only");
1715
1716   static std::vector<UniformData> customUniforms =
1717     {
1718       UniformData("uObjectMatrix", Property::Type::MATRIX),
1719     };
1720
1721   TestGraphicsController& graphics = application.GetGraphicsController();
1722   graphics.AddCustomUniforms(customUniforms);
1723
1724   //Set up visual properties.
1725   Property::Map propertyMap;
1726   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1727   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1728
1729   //Test to see if mesh loads correctly.
1730   MeshVisualLoadsCorrectlyTest(propertyMap, application);
1731
1732   END_TEST;
1733 }
1734
1735 //Test if mesh loads correctly when supplied with an object file as well as a blank material file and images directory.
1736 int UtcDaliVisualFactoryGetMeshVisual2(void)
1737 {
1738   //Set up test application first, so everything else can be handled.
1739   ToolkitTestApplication application;
1740
1741   tet_infoline("UtcDaliVisualFactoryGetMeshVisual2:  Request mesh visual with blank material file and images directory");
1742
1743   static std::vector<UniformData> customUniforms =
1744     {
1745       UniformData("uObjectMatrix", Property::Type::MATRIX),
1746     };
1747
1748   TestGraphicsController& graphics = application.GetGraphicsController();
1749   graphics.AddCustomUniforms(customUniforms);
1750
1751   //Set up visual properties.
1752   Property::Map propertyMap;
1753   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1754   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1755   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, "");
1756   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, "");
1757
1758   //Test to see if mesh loads correctly.
1759   MeshVisualLoadsCorrectlyTest(propertyMap, application);
1760
1761   END_TEST;
1762 }
1763
1764 //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
1765 int UtcDaliVisualFactoryGetMeshVisual3b(void)
1766 {
1767   //Set up test application first, so everything else can be handled.
1768   ToolkitTestApplication application;
1769
1770   tet_infoline("UtcDaliVisualFactoryGetMeshVisual3:  Request mesh visual with all parameters correct");
1771
1772   static std::vector<UniformData> customUniforms =
1773     {
1774       UniformData("uObjectMatrix", Property::Type::MATRIX),
1775     };
1776
1777   TestGraphicsController& graphics = application.GetGraphicsController();
1778   graphics.AddCustomUniforms(customUniforms);
1779
1780   //Set up visual properties.
1781   Property::Map propertyMap;
1782   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1783   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1784   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1785   propertyMap.Insert(MeshVisual::Property::USE_MIPMAPPING, Color::GREEN); // Test that wrong property types don't prevent the object load
1786   propertyMap.Insert(MeshVisual::Property::USE_SOFT_NORMALS, 1.0f);
1787   propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, 1.0f);
1788   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/");
1789
1790   //Test to see if mesh loads correctly.
1791   MeshVisualLoadsCorrectlyTest(propertyMap, application);
1792
1793   END_TEST;
1794 }
1795
1796 //Test if mesh loads correctly when supplied with all main parameters, an object file, a material file and a directory location.
1797 int UtcDaliVisualFactoryGetMeshVisual3(void)
1798 {
1799   //Set up test application first, so everything else can be handled.
1800   ToolkitTestApplication application;
1801
1802   tet_infoline("UtcDaliVisualFactoryGetMeshVisual3:  Request mesh visual with all parameters correct");
1803
1804   static std::vector<UniformData> customUniforms =
1805     {
1806       UniformData("uObjectMatrix", Property::Type::MATRIX),
1807     };
1808
1809   TestGraphicsController& graphics = application.GetGraphicsController();
1810   graphics.AddCustomUniforms(customUniforms);
1811
1812   //Set up visual properties.
1813   Property::Map propertyMap;
1814   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1815   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1816   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1817   propertyMap.Insert(MeshVisual::Property::USE_MIPMAPPING, false);
1818   propertyMap.Insert(MeshVisual::Property::USE_SOFT_NORMALS, false);
1819   propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3::XAXIS);
1820   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/");
1821
1822   //Test to see if mesh loads correctly.
1823   MeshVisualLoadsCorrectlyTest(propertyMap, application);
1824
1825   END_TEST;
1826 }
1827
1828 //Test if mesh visual can load a correctly supplied mesh without a normal map or gloss map in the material file.
1829 int UtcDaliVisualFactoryGetMeshVisual4(void)
1830 {
1831   //Set up test application first, so everything else can be handled.
1832   ToolkitTestApplication application;
1833
1834   tet_infoline("UtcDaliVisualFactoryGetMeshVisual4:  Request mesh visual with diffuse texture but not normal or gloss.");
1835
1836   static std::vector<UniformData> customUniforms =
1837     {
1838       UniformData("uObjectMatrix", Property::Type::MATRIX),
1839     };
1840
1841   TestGraphicsController& graphics = application.GetGraphicsController();
1842   graphics.AddCustomUniforms(customUniforms);
1843
1844   //Set up visual properties.
1845   Property::Map propertyMap;
1846   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1847   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1848   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_SIMPLE_MTL_FILE_NAME);
1849   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/");
1850
1851   //Test to see if mesh loads correctly.
1852   MeshVisualLoadsCorrectlyTest(propertyMap, application);
1853
1854   END_TEST;
1855 }
1856
1857 //Test if mesh visual can load when made to use diffuse textures only.
1858 int UtcDaliVisualFactoryGetMeshVisual5(void)
1859 {
1860   //Set up test application first, so everything else can be handled.
1861   ToolkitTestApplication application;
1862
1863   tet_infoline("UtcDaliVisualFactoryGetMeshVisual5:  Request mesh visual and make it only use diffuse textures.");
1864
1865   static std::vector<UniformData> customUniforms =
1866     {
1867       UniformData("uObjectMatrix", Property::Type::MATRIX),
1868     };
1869
1870   TestGraphicsController& graphics = application.GetGraphicsController();
1871   graphics.AddCustomUniforms(customUniforms);
1872
1873   //Set up visual properties.
1874   Property::Map propertyMap;
1875   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1876   propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
1877   propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
1878   propertyMap.Insert("texturesPath", TEST_RESOURCE_DIR "/");
1879   propertyMap.Insert("useMipmapping", false);
1880   propertyMap.Insert("useSoftNormals", false);
1881   propertyMap.Insert("lightPosition", Vector3::ZAXIS);
1882   propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURED_WITH_SPECULAR_LIGHTING);
1883
1884   //Test to see if mesh loads correctly.
1885   MeshVisualLoadsCorrectlyTest(propertyMap, application);
1886
1887   END_TEST;
1888 }
1889
1890 //Test if mesh visual can load when made to not use the supplied textures.
1891 int UtcDaliVisualFactoryGetMeshVisual6(void)
1892 {
1893   //Set up test application first, so everything else can be handled.
1894   ToolkitTestApplication application;
1895
1896   tet_infoline("UtcDaliVisualFactoryGetMeshVisual6:  Request mesh visual and make it not use any textures.");
1897
1898   static std::vector<UniformData> customUniforms =
1899     {
1900       UniformData("uObjectMatrix", Property::Type::MATRIX),
1901     };
1902
1903   TestGraphicsController& graphics = application.GetGraphicsController();
1904   graphics.AddCustomUniforms(customUniforms);
1905
1906   //Set up visual properties.
1907   Property::Map propertyMap;
1908   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1909   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1910   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1911   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/");
1912   propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1913
1914   //Test to see if mesh loads correctly.
1915   MeshVisualLoadsCorrectlyTest(propertyMap, application);
1916
1917   END_TEST;
1918 }
1919 //Test if mesh visual loads correctly when light position is manually set.
1920 int UtcDaliVisualFactoryGetMeshVisual7(void)
1921 {
1922   //Set up test application first, so everything else can be handled.
1923   ToolkitTestApplication application;
1924
1925   tet_infoline("UtcDaliVisualFactoryGetMeshVisual7:  Request mesh visual with custom light position.");
1926
1927   static std::vector<UniformData> customUniforms =
1928     {
1929       UniformData("uObjectMatrix", Property::Type::MATRIX),
1930     };
1931
1932   TestGraphicsController& graphics = application.GetGraphicsController();
1933   graphics.AddCustomUniforms(customUniforms);
1934
1935   //Set up visual properties.
1936   Property::Map propertyMap;
1937   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1938   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1939   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1940   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/");
1941   propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(0.0, 1.0, 2.0));
1942
1943   //Test to see if mesh loads correctly.
1944   MeshVisualLoadsCorrectlyTest(propertyMap, application);
1945
1946   END_TEST;
1947 }
1948
1949 //Test if mesh visual loads correctly when supplied an object file without face normals or texture points.
1950 //Note that this notably tests object loader functionality.
1951 int UtcDaliVisualFactoryGetMeshVisual8(void)
1952 {
1953   //Set up test application first, so everything else can be handled.
1954   ToolkitTestApplication application;
1955
1956   tet_infoline("UtcDaliVisualFactoryGetMeshVisual5:  Request mesh visual with normal-less object file.");
1957
1958   static std::vector<UniformData> customUniforms =
1959     {
1960       UniformData("uObjectMatrix", Property::Type::MATRIX),
1961     };
1962
1963   TestGraphicsController& graphics = application.GetGraphicsController();
1964   graphics.AddCustomUniforms(customUniforms);
1965
1966   //Set up visual properties.
1967   Property::Map propertyMap;
1968   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1969   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_SIMPLE_OBJ_FILE_NAME);
1970   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1971   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/");
1972
1973   //Test to see if mesh loads correctly.
1974   MeshVisualLoadsCorrectlyTest(propertyMap, application);
1975
1976   END_TEST;
1977 }
1978
1979 //Test if mesh visual handles the case of lacking an object file.
1980 int UtcDaliVisualFactoryGetMeshVisualN1(void)
1981 {
1982   //Set up test application first, so everything else can be handled.
1983   ToolkitTestApplication application;
1984
1985   tet_infoline("UtcDaliVisualFactoryGetMeshVisualN1:  Request mesh visual without object file");
1986
1987   //Set up visual properties.
1988   Property::Map propertyMap;
1989   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1990   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1991   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/");
1992
1993   //Test to see if mesh doesn't load with these properties, as expected.
1994   MeshVisualDoesNotLoadCorrectlyTest(propertyMap, application);
1995
1996   END_TEST;
1997 }
1998
1999 //Test if mesh visual handles the case of being passed invalid material and images urls.
2000 int UtcDaliVisualFactoryGetMeshVisualN2(void)
2001 {
2002   //Set up test application first, so everything else can be handled.
2003   ToolkitTestApplication application;
2004
2005   tet_infoline("UtcDaliVisualFactoryGetMeshVisualN2:  Request mesh visual with invalid material and images urls");
2006
2007   //Set up visual properties.
2008   Property::Map propertyMap;
2009   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
2010   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
2011   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, "invalid");
2012   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, "also invalid");
2013
2014   //Test to see if mesh doesn't load with these properties, as expected.
2015   MeshVisualDoesNotLoadCorrectlyTest(propertyMap, application);
2016
2017   END_TEST;
2018 }
2019
2020 //Test if mesh visual handles the case of being passed an invalid object url
2021 int UtcDaliVisualFactoryGetMeshVisualN3(void)
2022 {
2023   //Set up test application first, so everything else can be handled.
2024   ToolkitTestApplication application;
2025   tet_infoline("UtcDaliVisualFactoryGetMeshVisualN3:  Request mesh visual with invalid object url");
2026
2027   //Set up visual properties.
2028   Property::Map propertyMap;
2029   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
2030   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, "invalid");
2031   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
2032   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_DIR "/");
2033
2034   //Test to see if mesh doesn't load with these properties, as expected.
2035   MeshVisualDoesNotLoadCorrectlyTest(propertyMap, application);
2036
2037   END_TEST;
2038 }
2039
2040 //Creates a primitive visual with the given property map and tests to see if it correctly loads in the given application.
2041 void TestPrimitiveVisualWithProperties(Property::Map& propertyMap, ToolkitTestApplication& application)
2042 {
2043   VisualFactory factory = VisualFactory::Get();
2044   DALI_TEST_CHECK(factory);
2045
2046   //Create a primitive visual.
2047   Visual::Base visual = factory.CreateVisual(propertyMap);
2048   DALI_TEST_CHECK(visual);
2049
2050   //Create an actor on stage to house the visual.
2051   DummyControl      actor     = DummyControl::New(true);
2052   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
2053   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2054
2055   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2056   application.GetScene().Add(actor);
2057   visual.SetTransformAndSize(DefaultTransform(), Vector2(200.f, 200.f));
2058
2059   //Ensure set on stage.
2060   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2061
2062   //Tell test application to load the visual.
2063   application.SendNotification();
2064   application.Render(0);
2065
2066   Matrix testScaleMatrix;
2067   testScaleMatrix.SetIdentityAndScale(Vector3(1.0, -1.0, 1.0));
2068   Matrix actualScaleMatrix;
2069
2070   //Test to see if the object has been successfully loaded.
2071   DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Matrix>("uObjectMatrix", actualScaleMatrix));
2072   DALI_TEST_EQUALS(actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2073
2074   //Finish by setting off stage, and ensuring this was successful.
2075   actor.Unparent();
2076   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
2077 }
2078
2079 //Test if primitive shape loads correctly when supplied with only the bare minimum requirements, the shape to use.
2080 int UtcDaliVisualFactoryGetPrimitiveVisual1(void)
2081 {
2082   //Set up test application first, so everything else can be handled.
2083   ToolkitTestApplication application;
2084
2085   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual1:  Request primitive visual with a shape only");
2086
2087   static std::vector<UniformData> customUniforms =
2088     {
2089       UniformData("uObjectMatrix", Property::Type::MATRIX),
2090     };
2091
2092   TestGraphicsController& graphics = application.GetGraphicsController();
2093   graphics.AddCustomUniforms(customUniforms);
2094
2095   //Set up visual properties.
2096   Property::Map propertyMap;
2097   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2098   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2099
2100   //Test to see if shape loads correctly.
2101   TestPrimitiveVisualWithProperties(propertyMap, application);
2102
2103   END_TEST;
2104 }
2105
2106 //Test if primitive shape loads correctly when supplied with all possible parameters
2107 int UtcDaliVisualFactoryGetPrimitiveVisual2(void)
2108 {
2109   //Set up test application first, so everything else can be handled.
2110   ToolkitTestApplication application;
2111
2112   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual2:  Request primitive visual with everything");
2113
2114   static std::vector<UniformData> customUniforms =
2115     {
2116       UniformData("uObjectMatrix", Property::Type::MATRIX),
2117     };
2118
2119   TestGraphicsController& graphics = application.GetGraphicsController();
2120   graphics.AddCustomUniforms(customUniforms);
2121
2122   //Set up visual properties.
2123   Property::Map propertyMap;
2124   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2125   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2126   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Vector4(0.5, 0.5, 0.5, 1.0));
2127   propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
2128   propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
2129   propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
2130   propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
2131   propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
2132   propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
2133   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.7f);
2134   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.8f);
2135   propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(0.9, 1.0, 1.1));
2136
2137   //Test to see if shape loads correctly.
2138   TestPrimitiveVisualWithProperties(propertyMap, application);
2139
2140   END_TEST;
2141 }
2142
2143 //Test if primitive shape loads a sphere correctly.
2144 int UtcDaliVisualFactoryGetPrimitiveVisual3(void)
2145 {
2146   //Set up test application first, so everything else can be handled.
2147   ToolkitTestApplication application;
2148
2149   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual3:  Request primitive visual to display a sphere");
2150
2151   static std::vector<UniformData> customUniforms =
2152     {
2153       UniformData("uObjectMatrix", Property::Type::MATRIX),
2154     };
2155
2156   TestGraphicsController& graphics = application.GetGraphicsController();
2157   graphics.AddCustomUniforms(customUniforms);
2158
2159   //Set up visual properties.
2160   Property::Map propertyMap;
2161   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2162   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2163   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Vector4(0.5, 0.5, 0.5, 1.0));
2164   propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
2165   propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
2166
2167   //Test to see if shape loads correctly.
2168   TestPrimitiveVisualWithProperties(propertyMap, application);
2169
2170   END_TEST;
2171 }
2172
2173 //Test if primitive shape loads a conic section correctly.
2174 int UtcDaliVisualFactoryGetPrimitiveVisual4(void)
2175 {
2176   //Set up test application first, so everything else can be handled.
2177   ToolkitTestApplication application;
2178
2179   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual4:  Request primitive visual to display a conic section");
2180
2181   static std::vector<UniformData> customUniforms =
2182     {
2183       UniformData("uObjectMatrix", Property::Type::MATRIX),
2184     };
2185
2186   TestGraphicsController& graphics = application.GetGraphicsController();
2187   graphics.AddCustomUniforms(customUniforms);
2188
2189   //Set up visual properties.
2190   Property::Map propertyMap;
2191   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2192   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CONICAL_FRUSTUM);
2193   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Vector4(0.5, 0.5, 0.5, 1.0));
2194   propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
2195   propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
2196   propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
2197   propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
2198
2199   //Test to see if shape loads correctly.
2200   TestPrimitiveVisualWithProperties(propertyMap, application);
2201
2202   END_TEST;
2203 }
2204
2205 //Test if primitive shape loads a bevelled cube correctly.
2206 int UtcDaliVisualFactoryGetPrimitiveVisual5(void)
2207 {
2208   //Set up test application first, so everything else can be handled.
2209   ToolkitTestApplication application;
2210
2211   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual5:  Request primitive visual to display a bevelled cube");
2212
2213   static std::vector<UniformData> customUniforms =
2214     {
2215       UniformData("uObjectMatrix", Property::Type::MATRIX),
2216     };
2217
2218   TestGraphicsController& graphics = application.GetGraphicsController();
2219   graphics.AddCustomUniforms(customUniforms);
2220
2221   //Set up visual properties.
2222   Property::Map propertyMap;
2223   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2224   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::BEVELLED_CUBE);
2225   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Vector4(0.5, 0.5, 0.5, 1.0));
2226   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.7f);
2227
2228   //Test to see if shape loads correctly.
2229   TestPrimitiveVisualWithProperties(propertyMap, application);
2230
2231   END_TEST;
2232 }
2233
2234 //Test if primitive shape loads an octahedron correctly.
2235 int UtcDaliVisualFactoryGetPrimitiveVisual6(void)
2236 {
2237   //Set up test application first, so everything else can be handled.
2238   ToolkitTestApplication application;
2239
2240   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual6:  Request primitive visual to display an octahedron");
2241
2242   static std::vector<UniformData> customUniforms =
2243     {
2244       UniformData("uObjectMatrix", Property::Type::MATRIX),
2245     };
2246
2247   TestGraphicsController& graphics = application.GetGraphicsController();
2248   graphics.AddCustomUniforms(customUniforms);
2249
2250   //Set up visual properties.
2251   Property::Map propertyMap;
2252   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2253   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::OCTAHEDRON);
2254   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Vector4(0.5, 0.5, 0.5, 1.0));
2255
2256   //Test to see if shape loads correctly.
2257   TestPrimitiveVisualWithProperties(propertyMap, application);
2258
2259   END_TEST;
2260 }
2261
2262 //Test if primitive shape loads a cone correctly.
2263 int UtcDaliVisualFactoryGetPrimitiveVisual7(void)
2264 {
2265   //Set up test application first, so everything else can be handled.
2266   ToolkitTestApplication application;
2267
2268   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual7:  Request primitive visual to display a cone");
2269
2270   static std::vector<UniformData> customUniforms =
2271     {
2272       UniformData("uObjectMatrix", Property::Type::MATRIX),
2273     };
2274
2275   TestGraphicsController& graphics = application.GetGraphicsController();
2276   graphics.AddCustomUniforms(customUniforms);
2277
2278   //Set up visual properties.
2279   Property::Map propertyMap;
2280   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2281   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CONE);
2282   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Vector4(0.5, 0.5, 0.5, 1.0));
2283   propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
2284   propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
2285   propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
2286
2287   //Test to see if shape loads correctly.
2288   TestPrimitiveVisualWithProperties(propertyMap, application);
2289
2290   END_TEST;
2291 }
2292
2293 //Test if primitive shape loads correctly when light position is manually set.
2294 int UtcDaliVisualFactoryGetPrimitiveVisual8(void)
2295 {
2296   //Set up test application first, so everything else can be handled.
2297   ToolkitTestApplication application;
2298
2299   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual8:  Request primitive visual with set light position");
2300
2301   static std::vector<UniformData> customUniforms =
2302     {
2303       UniformData("uObjectMatrix", Property::Type::MATRIX),
2304     };
2305
2306   TestGraphicsController& graphics = application.GetGraphicsController();
2307   graphics.AddCustomUniforms(customUniforms);
2308
2309   //Set up visual properties.
2310   Property::Map propertyMap;
2311   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2312   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2313   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Vector4(0.5, 0.5, 0.5, 1.0));
2314   propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(0.0, 1.0, 2.0));
2315
2316   //Test to see if shape loads correctly.
2317   TestPrimitiveVisualWithProperties(propertyMap, application);
2318
2319   END_TEST;
2320 }
2321
2322 //Test if primitive shape loads correctly when told to use too many slices.
2323 int UtcDaliVisualFactoryGetPrimitiveVisual9(void)
2324 {
2325   //Set up test application first, so everything else can be handled.
2326   ToolkitTestApplication application;
2327
2328   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual9:  Request primitive visual with above-cap slices.");
2329
2330   static std::vector<UniformData> customUniforms =
2331     {
2332       UniformData("uObjectMatrix", Property::Type::MATRIX),
2333     };
2334
2335   TestGraphicsController& graphics = application.GetGraphicsController();
2336   graphics.AddCustomUniforms(customUniforms);
2337
2338   //Set up visual properties.
2339   Property::Map propertyMap;
2340   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2341   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2342   propertyMap.Insert(PrimitiveVisual::Property::SLICES, Property::Value(1000000));
2343
2344   //Test to see if shape loads correctly.
2345   TestPrimitiveVisualWithProperties(propertyMap, application);
2346
2347   END_TEST;
2348 }
2349
2350 //Test if primitive shape loads correctly when told to use too few slices. (2 slices or less.)
2351 int UtcDaliVisualFactoryGetPrimitiveVisual10(void)
2352 {
2353   //Set up test application first, so everything else can be handled.
2354   ToolkitTestApplication application;
2355
2356   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual10:  Request primitive visual with too few slices.");
2357
2358   static std::vector<UniformData> customUniforms =
2359     {
2360       UniformData("uObjectMatrix", Property::Type::MATRIX),
2361     };
2362
2363   TestGraphicsController& graphics = application.GetGraphicsController();
2364   graphics.AddCustomUniforms(customUniforms);
2365
2366   //Set up visual properties.
2367   Property::Map propertyMap;
2368   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2369   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2370   propertyMap.Insert(PrimitiveVisual::Property::SLICES, Property::Value(2));
2371
2372   //Test to see if shape loads correctly.
2373   TestPrimitiveVisualWithProperties(propertyMap, application);
2374
2375   END_TEST;
2376 }
2377
2378 //Test if primitive shape loads correctly when told to use too many stacks.
2379 int UtcDaliVisualFactoryGetPrimitiveVisual11(void)
2380 {
2381   //Set up test application first, so everything else can be handled.
2382   ToolkitTestApplication application;
2383
2384   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual11:  Request primitive visual with too many stacks.");
2385
2386   static std::vector<UniformData> customUniforms =
2387     {
2388       UniformData("uObjectMatrix", Property::Type::MATRIX),
2389     };
2390
2391   TestGraphicsController& graphics = application.GetGraphicsController();
2392   graphics.AddCustomUniforms(customUniforms);
2393
2394   //Set up visual properties.
2395   Property::Map propertyMap;
2396   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2397   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2398   propertyMap.Insert(PrimitiveVisual::Property::STACKS, Property::Value(1000000));
2399
2400   //Test to see if shape loads correctly.
2401   TestPrimitiveVisualWithProperties(propertyMap, application);
2402
2403   END_TEST;
2404 }
2405
2406 //Test if primitive shape loads correctly when told to use too few stacks. (1 stack or less.)
2407 int UtcDaliVisualFactoryGetPrimitiveVisual12(void)
2408 {
2409   //Set up test application first, so everything else can be handled.
2410   ToolkitTestApplication application;
2411
2412   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual12:  Request primitive visual with too few stacks.");
2413
2414   static std::vector<UniformData> customUniforms =
2415     {
2416       UniformData("uObjectMatrix", Property::Type::MATRIX),
2417     };
2418
2419   TestGraphicsController& graphics = application.GetGraphicsController();
2420   graphics.AddCustomUniforms(customUniforms);
2421
2422   //Set up visual properties.
2423   Property::Map propertyMap;
2424   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2425   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2426   propertyMap.Insert(PrimitiveVisual::Property::STACKS, Property::Value(1));
2427
2428   //Test to see if shape loads correctly.
2429   TestPrimitiveVisualWithProperties(propertyMap, application);
2430
2431   END_TEST;
2432 }
2433
2434 //Test if primitive shape loads correctly when told to use invalid (zero or negative) dimensions.
2435 int UtcDaliVisualFactoryGetPrimitiveVisual13(void)
2436 {
2437   //Set up test application first, so everything else can be handled.
2438   ToolkitTestApplication application;
2439
2440   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual13:  Request primitive visual with invalid scale dimensions.");
2441
2442   static std::vector<UniformData> customUniforms =
2443     {
2444       UniformData("uObjectMatrix", Property::Type::MATRIX),
2445     };
2446
2447   TestGraphicsController& graphics = application.GetGraphicsController();
2448   graphics.AddCustomUniforms(customUniforms);
2449
2450   //Set up visual properties.
2451   Property::Map propertyMap;
2452   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2453   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2454   propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, Vector3::ZERO);
2455
2456   //Test to see if shape loads correctly.
2457   TestPrimitiveVisualWithProperties(propertyMap, application);
2458
2459   END_TEST;
2460 }
2461
2462 //Test if primitive shape loads correctly when told to use too low a bevel percentage.
2463 int UtcDaliVisualFactoryGetPrimitiveVisual14(void)
2464 {
2465   //Set up test application first, so everything else can be handled.
2466   ToolkitTestApplication application;
2467
2468   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual14:  Request primitive visual with too low a bevel percentage.");
2469
2470   static std::vector<UniformData> customUniforms =
2471     {
2472       UniformData("uObjectMatrix", Property::Type::MATRIX),
2473     };
2474
2475   TestGraphicsController& graphics = application.GetGraphicsController();
2476   graphics.AddCustomUniforms(customUniforms);
2477
2478   //Set up visual properties.
2479   Property::Map propertyMap;
2480   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2481   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2482   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::Value(-1.0f));
2483
2484   //Test to see if shape loads correctly.
2485   TestPrimitiveVisualWithProperties(propertyMap, application);
2486
2487   END_TEST;
2488 }
2489
2490 //Test if primitive shape loads correctly when told to use too high a bevel percentage.
2491 int UtcDaliVisualFactoryGetPrimitiveVisual15(void)
2492 {
2493   //Set up test application first, so everything else can be handled.
2494   ToolkitTestApplication application;
2495
2496   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual15:  Request primitive visual with too high a bevel percentage.");
2497
2498   static std::vector<UniformData> customUniforms =
2499     {
2500       UniformData("uObjectMatrix", Property::Type::MATRIX),
2501     };
2502
2503   TestGraphicsController& graphics = application.GetGraphicsController();
2504   graphics.AddCustomUniforms(customUniforms);
2505
2506   //Set up visual properties.
2507   Property::Map propertyMap;
2508   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2509   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2510   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::Value(2.0f));
2511
2512   //Test to see if shape loads correctly.
2513   TestPrimitiveVisualWithProperties(propertyMap, application);
2514
2515   END_TEST;
2516 }
2517
2518 //Test if primitive shape loads correctly when told to use too low a bevel smoothness.
2519 int UtcDaliVisualFactoryGetPrimitiveVisual16(void)
2520 {
2521   //Set up test application first, so everything else can be handled.
2522   ToolkitTestApplication application;
2523
2524   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual16:  Request primitive visual with too low a bevel smoothness.");
2525
2526   static std::vector<UniformData> customUniforms =
2527     {
2528       UniformData("uObjectMatrix", Property::Type::MATRIX),
2529     };
2530
2531   TestGraphicsController& graphics = application.GetGraphicsController();
2532   graphics.AddCustomUniforms(customUniforms);
2533
2534   //Set up visual properties.
2535   Property::Map propertyMap;
2536   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2537   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2538   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::Value(-1.0f));
2539
2540   //Test to see if shape loads correctly.
2541   TestPrimitiveVisualWithProperties(propertyMap, application);
2542
2543   END_TEST;
2544 }
2545
2546 //Test if primitive shape loads correctly when told to use too high a bevel smoothness.
2547 int UtcDaliVisualFactoryGetPrimitiveVisual17(void)
2548 {
2549   //Set up test application first, so everything else can be handled.
2550   ToolkitTestApplication application;
2551
2552   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual17:  Request primitive visual with too high a bevel smoothness.");
2553
2554   static std::vector<UniformData> customUniforms =
2555     {
2556       UniformData("uObjectMatrix", Property::Type::MATRIX),
2557     };
2558
2559   TestGraphicsController& graphics = application.GetGraphicsController();
2560   graphics.AddCustomUniforms(customUniforms);
2561
2562   //Set up visual properties.
2563   Property::Map propertyMap;
2564   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2565   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::SPHERE);
2566   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::Value(2.0f));
2567
2568   //Test to see if shape loads correctly.
2569   TestPrimitiveVisualWithProperties(propertyMap, application);
2570
2571   END_TEST;
2572 }
2573
2574 //Test if primitive shape loads a conic section correctly.
2575 int UtcDaliVisualFactoryGetPrimitiveVisual18(void)
2576 {
2577   //Set up test application first, so everything else can be handled.
2578   ToolkitTestApplication application;
2579
2580   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisual18:  Request primitive visual to display a conic section");
2581
2582   static std::vector<UniformData> customUniforms =
2583     {
2584       UniformData("uObjectMatrix", Property::Type::MATRIX),
2585     };
2586
2587   TestGraphicsController& graphics = application.GetGraphicsController();
2588   graphics.AddCustomUniforms(customUniforms);
2589
2590   //Set up visual properties.
2591   Property::Map propertyMap;
2592   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2593   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CONICAL_FRUSTUM);
2594   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Vector4(0.5, 0.5, 0.5, 1.0));
2595   propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
2596   propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
2597   propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
2598   propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
2599
2600   //Test to see if shape loads correctly.
2601   TestPrimitiveVisualWithProperties(propertyMap, application);
2602
2603   END_TEST;
2604 }
2605
2606 //Test if primitive shape visual handles the case of not being passed a specific shape to use.
2607 int UtcDaliVisualFactoryGetPrimitiveVisualN1(void)
2608 {
2609   //Set up test application first, so everything else can be handled.
2610   ToolkitTestApplication application;
2611
2612   tet_infoline("UtcDaliVisualFactoryGetPrimitiveVisualN1:  Request primitive visual without shape");
2613
2614   static std::vector<UniformData> customUniforms =
2615     {
2616       UniformData("uObjectMatrix", Property::Type::MATRIX),
2617     };
2618
2619   TestGraphicsController& graphics = application.GetGraphicsController();
2620   graphics.AddCustomUniforms(customUniforms);
2621
2622   //Set up visual properties, without supplying shape.
2623   Property::Map propertyMap;
2624   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
2625
2626   //Test to see if shape loads regardless of missing input.
2627   TestPrimitiveVisualWithProperties(propertyMap, application);
2628
2629   END_TEST;
2630 }
2631
2632 int UtcDaliVisualFactoryGetAnimatedImageVisual1(void)
2633 {
2634   ToolkitTestApplication application;
2635   tet_infoline("UtcDaliVisualFactoryGetAnimatedImageVisual1: Request animated image visual with a gif url");
2636
2637   TestGlAbstraction& gl           = application.GetGlAbstraction();
2638   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2639   textureTrace.Enable(true);
2640
2641   VisualFactory factory = VisualFactory::Get();
2642   Visual::Base  visual  = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
2643   DALI_TEST_CHECK(visual);
2644
2645   DummyControl      actor     = DummyControl::New(true);
2646   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
2647   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2648   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2649   application.GetScene().Add(actor);
2650
2651   application.SendNotification();
2652   application.Render();
2653
2654   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
2655
2656   application.SendNotification();
2657   application.Render();
2658
2659   // renderer is added to actor
2660   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
2661   Renderer renderer = actor.GetRendererAt(0u);
2662   DALI_TEST_CHECK(renderer);
2663
2664   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2665   textureTrace.Reset();
2666
2667   // Force the timer used by the animatedImageVisual to tick,
2668   Dali::Timer timer = Timer::New(0);
2669   timer.MockEmitSignal();
2670   application.SendNotification();
2671   application.Render();
2672
2673   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2674
2675   application.SendNotification();
2676   application.Render();
2677   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2678   textureTrace.Reset();
2679
2680   // Force the timer used by the animatedImageVisual to tick,
2681   timer.MockEmitSignal();
2682   application.SendNotification();
2683   application.Render();
2684
2685   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2686
2687   application.SendNotification();
2688   application.Render();
2689   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2690   textureTrace.Reset();
2691
2692   // Force the timer used by the animatedImageVisual to tick,
2693   timer.MockEmitSignal();
2694   application.SendNotification();
2695   application.Render();
2696
2697   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2698
2699   application.SendNotification();
2700   application.Render();
2701   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2702   textureTrace.Reset();
2703
2704   // Test SetOffScene().
2705   actor.Unparent();
2706   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2707
2708   END_TEST;
2709 }
2710
2711 int UtcDaliVisualFactoryGetAnimatedImageVisual2(void)
2712 {
2713   ToolkitTestApplication application;
2714   tet_infoline("UtcDaliVisualFactoryGetAnimatedImageVisual2: Request animated image visual with a Property::Map, test custom wrap mode and pixel area");
2715
2716   static std::vector<UniformData> customUniforms =
2717     {
2718       UniformData("pixelArea", Property::Type::VECTOR4),
2719       UniformData("wrapMode", Property::Type::VECTOR2),
2720     };
2721
2722   TestGraphicsController& graphics = application.GetGraphicsController();
2723   graphics.AddCustomUniforms(customUniforms);
2724
2725   const Vector4 pixelArea(-0.5f, -0.5f, 2.f, 2.f);
2726   Property::Map propertyMap;
2727   propertyMap.Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
2728     .Add(ImageVisual::Property::URL, TEST_GIF_FILE_NAME)
2729     .Add(ImageVisual::Property::PIXEL_AREA, pixelArea)
2730     .Add(ImageVisual::Property::WRAP_MODE_U, WrapMode::MIRRORED_REPEAT)
2731     .Add(ImageVisual::Property::WRAP_MODE_V, WrapMode::REPEAT);
2732
2733   Visual::Base visual = VisualFactory::Get().CreateVisual(propertyMap);
2734   DALI_TEST_CHECK(visual);
2735
2736   TestGlAbstraction& gl           = application.GetGlAbstraction();
2737   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2738   textureTrace.Enable(true);
2739   TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
2740   texParameterTrace.Enable(true);
2741
2742   DummyControl      actor     = DummyControl::New(true);
2743   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
2744   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
2745   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2746   application.GetScene().Add(actor);
2747
2748   application.SendNotification();
2749   application.Render();
2750
2751   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
2752
2753   application.SendNotification();
2754   application.Render();
2755
2756   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
2757
2758   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
2759
2760   // For animated image visual, the wrapping is handled manually in shader, so the following gl function should not be called
2761   std::stringstream out;
2762   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_S << ", " << GL_MIRRORED_REPEAT;
2763   DALI_TEST_CHECK(!texParameterTrace.FindMethodAndParams("TexParameteri", out.str()));
2764   out.str("");
2765   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_T << ", " << GL_REPEAT;
2766   DALI_TEST_CHECK(!texParameterTrace.FindMethodAndParams("TexParameteri", out.str()));
2767
2768   // test the uniforms which used to handle the wrap mode
2769   Renderer renderer = actor.GetRendererAt(0u);
2770   DALI_TEST_CHECK(renderer);
2771
2772   Property::Value pixelAreaValue = renderer.GetProperty(renderer.GetPropertyIndex("pixelArea"));
2773   DALI_TEST_EQUALS(pixelAreaValue.Get<Vector4>(), pixelArea, TEST_LOCATION);
2774   Vector4 pixelAreaUniform;
2775   DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("pixelArea", pixelAreaUniform));
2776   DALI_TEST_EQUALS(pixelArea, pixelAreaUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2777
2778   Property::Value wrapModeValue = renderer.GetProperty(renderer.GetPropertyIndex("wrapMode"));
2779   Vector2         wrapMode(WrapMode::MIRRORED_REPEAT - 1, WrapMode::REPEAT - 1);
2780   DALI_TEST_EQUALS(wrapModeValue.Get<Vector2>(), wrapMode, TEST_LOCATION);
2781   Vector2 wrapModeUniform;
2782   DALI_TEST_CHECK(gl.GetUniformValue<Vector2>("wrapMode", wrapModeUniform));
2783   DALI_TEST_EQUALS(wrapMode, wrapModeUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2784
2785   actor.Unparent();
2786   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2787
2788   END_TEST;
2789 }