automated-tests/src/dali-toolkit-internal/utc-Dali-DebugRendering.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 <unistd.h>
  18
  19 #include <dali-toolkit-test-suite-utils.h>
  20 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
  21 #include <dali-toolkit/internal/visuals/text/text-visual.h>
  22 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
  23 #include <dali-toolkit/internal/visuals/wireframe/wireframe-visual.h>
  24
  25 #include <dali-toolkit/dali-toolkit.h>
  26
  27 #include <toolkit-environment-variable.h> // for setting environment variable: DALI_DEBUG_RENDERING
  28
  29 #if defined(ELDBUS_ENABLED)
  30 #include <automated-tests/src/dali-toolkit-internal/dali-toolkit-test-utils/dbus-wrapper.h>
  31 #endif
  32
  33 #include "dummy-control.h"
  34
  35 using namespace Dali;
  36 using namespace Dali::Toolkit;
  37
  38 namespace
  39 {
  40 const char* TEST_IMAGE_FILE_NAME  = "image_01.jpg";
  41 const char* TEST_NPATCH_FILE_NAME = "image_01.9.jpg";
  42 const char* TEST_SVG_FILE_NAME    = TEST_RESOURCE_DIR "/svg1.svg";
  43 const char* TEST_GIF_FILE_NAME    = TEST_RESOURCE_DIR "/anim.gif";
  44
  45 const std::string DEFAULT_FONT_DIR("/resources/fonts");
  46 const char* const DALI_DEBUG_RENDERING("DALI_DEBUG_RENDERING");
  47
  48 void TestDebugVisual(Integration::Scene scene, Visual::Base& visual, DevelVisual::Type actualType, Vector2 expectedNaturalSize)
  49 {
  50   {
  51     auto& impl = GetImplementation(visual);
  52     DALI_TEST_CHECK(&typeid(Toolkit::Internal::WireframeVisual) == &typeid(impl));
  53   }
  54
  55   Vector2 naturalSize;
  56   visual.GetNaturalSize(naturalSize);
  57   DALI_TEST_EQUALS(naturalSize, expectedNaturalSize, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
  58
  59   Property::Map propertyMap;
  60   visual.CreatePropertyMap(propertyMap);
  61   Property::Value* typeValue = propertyMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
  62   if(typeValue)
  63   {
  64     DALI_TEST_CHECK(typeValue->Get<int>() == actualType);
  65   }
  66
  67   DummyControl      actor     = DummyControl::New();
  68   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
  69   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
  70   scene.Add(actor);
  71
  72   DALI_TEST_EQUALS(actor.GetRendererCount(), 1, TEST_LOCATION);
  73   if(actor.GetRendererCount() > 0)
  74   {
  75     Geometry geometry = actor.GetRendererAt(0).GetGeometry();
  76     DALI_TEST_CHECK(geometry.GetType() == Geometry::LINES);
  77   }
  78 }
  79 void TestDebugVisual(Integration::Scene scene, Visual::Base& visual, Visual::Type actualType, Vector2 expectedNaturalSize)
  80 {
  81   TestDebugVisual(scene, visual, (DevelVisual::Type)actualType, expectedNaturalSize);
  82 }
  83 } // namespace
  84
  85 void dali_debug_rendering_startup(void)
  86 {
  87   test_return_value = TET_UNDEF;
  88 #if defined(ELDBUS_ENABLED)
  89   DBusWrapper::Install(std::unique_ptr<DBusWrapper>(new TestDBusWrapper));
  90 #endif
  91 }
  92
  93 void dali_debug_rendering_cleanup(void)
  94 {
  95   test_return_value = TET_PASS;
  96 }
  97
  98 int UtcDaliDebugRenderingGetVisual1(void)
  99 {
 100   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "1");
 101   ToolkitTestApplication application;
 102   tet_infoline("UtcDaliDebugRenderingGetVisual1:  Request visual with a Property::Map");
 103
 104   VisualFactory factory = VisualFactory::Get();
 105   DALI_TEST_CHECK(factory);
 106
 107   // Test that color visual is replaced with debug visual
 108   Property::Map propertyMap1;
 109   propertyMap1.Insert(Visual::Property::TYPE, Visual::COLOR);
 110   propertyMap1.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
 111   Visual::Base colorVisual = factory.CreateVisual(propertyMap1);
 112   DALI_TEST_CHECK(colorVisual);
 113   TestDebugVisual(application.GetScene(), colorVisual, Visual::COLOR, Vector2::ZERO);
 114
 115   // Test that border visual is replaced with debug visual
 116   Property::Map propertyMap2;
 117   propertyMap2.Insert(Visual::Property::TYPE, Visual::BORDER);
 118   propertyMap2.Insert(BorderVisual::Property::COLOR, Color::BLUE);
 119   propertyMap2.Insert(BorderVisual::Property::SIZE, 2.f);
 120   Visual::Base borderVisual = factory.CreateVisual(propertyMap2);
 121   DALI_TEST_CHECK(borderVisual);
 122   TestDebugVisual(application.GetScene(), borderVisual, Visual::BORDER, Vector2::ZERO);
 123
 124   // Test that gradient visual is replaced with debug visual
 125   Property::Map propertyMap3;
 126   propertyMap3.Insert(Visual::Property::TYPE, Visual::GRADIENT);
 127   Vector2 start(-1.f, -1.f);
 128   Vector2 end(1.f, 1.f);
 129   propertyMap3.Insert(GradientVisual::Property::START_POSITION, start);
 130   propertyMap3.Insert(GradientVisual::Property::END_POSITION, end);
 131   propertyMap3.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
 132   Property::Array stopOffsets;
 133   stopOffsets.PushBack(0.2f);
 134   stopOffsets.PushBack(0.8f);
 135   propertyMap3.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
 136   Property::Array stopColors;
 137   stopColors.PushBack(Color::RED);
 138   stopColors.PushBack(Color::GREEN);
 139   propertyMap3.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
 140   Visual::Base gradientVisual = factory.CreateVisual(propertyMap3);
 141   DALI_TEST_CHECK(gradientVisual);
 142   TestDebugVisual(application.GetScene(), gradientVisual, Visual::GRADIENT, Vector2::ZERO);
 143
 144   // Test that image visual is replaced with debug visual
 145   Property::Map propertyMap4;
 146   propertyMap4.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
 147   propertyMap4.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
 148   propertyMap4.Insert(ImageVisual::Property::DESIRED_WIDTH, 50.f);
 149   propertyMap4.Insert(ImageVisual::Property::DESIRED_HEIGHT, 100.f);
 150   Visual::Base imageVisual = factory.CreateVisual(propertyMap4);
 151   DALI_TEST_CHECK(imageVisual);
 152   TestDebugVisual(application.GetScene(), imageVisual, Visual::IMAGE, Vector2(50.f, 100.f));
 153
 154   // Test that SVG visual is replaced with debug visual
 155   // TEST_SVG_FILE:
 156   //  <svg width="100" height="100">
 157   //  <circle cx="50" cy="50" r="40" stroke="green" stroke-width="4" fill="yellow" />
 158   //  </svg>
 159   Property::Map propertyMap5;
 160   propertyMap5.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
 161   propertyMap5.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
 162   Visual::Base svgVisual = factory.CreateVisual(propertyMap5);
 163   DALI_TEST_CHECK(svgVisual);
 164   TestDebugVisual(application.GetScene(), svgVisual, Visual::SVG, Vector2::ZERO);
 165
 166   // Test that AnimatedImageVisual is replaced with debug visual
 167   // TEST_GIF_FILE: anim.gif
 168   // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
 169   Property::Map propertyMap6;
 170   propertyMap6.Insert(Toolkit::Visual::Property::TYPE, Visual::ANIMATED_IMAGE);
 171   propertyMap6.Insert(ImageVisual::Property::URL, TEST_GIF_FILE_NAME);
 172   Visual::Base animatedImageVisual = factory.CreateVisual(propertyMap6);
 173   DALI_TEST_CHECK(animatedImageVisual);
 174   TestDebugVisual(application.GetScene(), animatedImageVisual, Visual::ANIMATED_IMAGE, Vector2(50.f, 50.f));
 175
 176   // Test that text visual is replaced with debug visual
 177
 178   // Load some fonts to get the same metrics on different platforms.
 179   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
 180   fontClient.SetDpi(96u, 96u);
 181
 182   char*             pathNamePtr = get_current_dir_name();
 183   const std::string pathName(pathNamePtr);
 184   free(pathNamePtr);
 185
 186   fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
 187
 188   Property::Map propertyMap7;
 189   propertyMap7.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
 190   propertyMap7.Insert(TextVisual::Property::ENABLE_MARKUP, true);
 191   propertyMap7.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
 192   propertyMap7.Insert(TextVisual::Property::MULTI_LINE, true);
 193
 194   Visual::Base textVisual = factory.CreateVisual(propertyMap7);
 195   DALI_TEST_CHECK(textVisual);
 196   {
 197     auto&& impl = GetImplementation(textVisual);
 198     DALI_TEST_CHECK(&typeid(Toolkit::Internal::WireframeVisual) == &typeid(impl));
 199   }
 200
 201   Vector2 naturalSize;
 202   textVisual.GetNaturalSize(naturalSize);
 203   DALI_TEST_EQUALS(naturalSize, Vector2(82.f, 20.f), Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 204
 205   const float height = textVisual.GetHeightForWidth(40.f);
 206   DALI_TEST_EQUALS(height, 60.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
 207
 208   // Test that NPatchVisual is replaced with debug visual
 209   // TEST_NPATCH_FILE_NAME: image_01.9.jpg
 210   Property::Map propertyMap8;
 211   propertyMap8.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
 212   propertyMap8.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
 213   Visual::Base nPatchVisual = factory.CreateVisual(propertyMap8);
 214   DALI_TEST_CHECK(nPatchVisual);
 215   TestDebugVisual(application.GetScene(), nPatchVisual, Visual::N_PATCH, Vector2::ZERO);
 216
 217   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "0");
 218   END_TEST;
 219 }
 220
 221 int UtcDaliDebugRenderingGetVisual2(void)
 222 {
 223   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "1");
 224   ToolkitTestApplication application;
 225   tet_infoline("UtcDaliDebugRenderingGetVisual2: Request visual with various parameters");
 226
 227   VisualFactory factory = VisualFactory::Get();
 228   DALI_TEST_CHECK(factory);
 229
 230   // Test that color visual is replaced with debug visual
 231   Dali::Property::Map map;
 232   map[Toolkit::Visual::Property::TYPE]  = Visual::COLOR;
 233   map[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
 234
 235   Visual::Base colorVisual = factory.CreateVisual(map);
 236   DALI_TEST_CHECK(colorVisual);
 237   TestDebugVisual(application.GetScene(), colorVisual, Visual::COLOR, Vector2::ZERO);
 238
 239   // Test that border visual is replaced with debug visual
 240   map.Clear();
 241   map[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
 242   map[BorderVisual::Property::COLOR]   = Color::GREEN;
 243   map[BorderVisual::Property::SIZE]    = 2.f;
 244   Visual::Base borderVisual            = factory.CreateVisual(map);
 245   DALI_TEST_CHECK(borderVisual);
 246   TestDebugVisual(application.GetScene(), borderVisual, Visual::BORDER, Vector2::ZERO);
 247
 248   // Test that image visual is replaced with debug visual
 249   map.Clear();
 250   map[Toolkit::Visual::Property::TYPE] = Visual::IMAGE;
 251   map[ImageVisual::Property::URL]      = TEST_IMAGE_FILE_NAME;
 252   Visual::Base imageVisual             = factory.CreateVisual(map);
 253   DALI_TEST_CHECK(imageVisual);
 254   TestDebugVisual(application.GetScene(), imageVisual, Visual::IMAGE, Vector2(64.0f, 64.0f /* Broken Image Size */));
 255
 256   // Test that n patch visual is replaced with debug visual
 257   Visual::Base nPatchVisual = factory.CreateVisual(TEST_NPATCH_FILE_NAME, ImageDimensions());
 258   DALI_TEST_CHECK(nPatchVisual);
 259   TestDebugVisual(application.GetScene(), nPatchVisual, Visual::N_PATCH, Vector2::ZERO);
 260
 261   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "0");
 262   END_TEST;
 263 }
 264
 265 int UtcDaliDebugRenderingGetVisual3(void)
 266 {
 267   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "1");
 268   ToolkitTestApplication application;
 269   tet_infoline("UtcDaliDebugRenderingGetVisual3: Request visual with various parameters");
 270
 271   VisualFactory factory = VisualFactory::Get();
 272   DALI_TEST_CHECK(factory);
 273
 274   // Test that image visual is replaced with debug visual
 275   Dali::Property::Map map;
 276   map[Toolkit::Visual::Property::TYPE] = Visual::IMAGE;
 277   map[ImageVisual::Property::URL]      = TEST_IMAGE_FILE_NAME;
 278   Visual::Base imageVisual             = factory.CreateVisual(map);
 279   DALI_TEST_CHECK(imageVisual);
 280   TestDebugVisual(application.GetScene(), imageVisual, Visual::IMAGE, Vector2(64.0f, 64.0f /* Broken Image Size */));
 281
 282   // Test that image visual with null string don't make visual
 283   map.Clear();
 284   map[Toolkit::Visual::Property::TYPE] = Visual::IMAGE;
 285   map[ImageVisual::Property::URL]      = "";
 286   Visual::Base emptyVisual             = factory.CreateVisual(map);
 287   DALI_TEST_CHECK(emptyVisual);
 288   TestDebugVisual(application.GetScene(), emptyVisual, Visual::WIREFRAME, Vector2::ZERO);
 289
 290   tet_infoline("Check that GetVisualObject returns the actual WireframeVisual");
 291   Toolkit::Internal::Visual::Base& visualImpl = GetImplementation(emptyVisual).GetVisualObject();
 292   DALI_TEST_CHECK(dynamic_cast<Toolkit::Internal::WireframeVisual*>(&visualImpl));
 293
 294   tet_infoline("Compare the returned emptyVisual with the visual implementation, should be the same");
 295   DALI_TEST_CHECK(emptyVisual.GetObjectPtr() == &visualImpl);
 296
 297   // Test that image view with empty property map don't make visual even DebugRendering is enabled.
 298   map.Clear();
 299   ImageView imageView1 = ImageView::New();
 300   imageView1.SetProperty(Control::Property::BACKGROUND, map);
 301   imageView1.SetProperty(ImageView::Property::IMAGE, map);
 302
 303   // Test that image view with empty property value don't make visual even DebugRendering is enabled.
 304   Property::Value emptyValue;
 305   ImageView       imageView2 = ImageView::New();
 306   imageView2.SetProperty(Control::Property::BACKGROUND, emptyValue);
 307   imageView2.SetProperty(ImageView::Property::IMAGE, emptyValue);
 308
 309   // Test that image view with invalid property value don't make visual even DebugRendering is enabled.
 310   Property::Value invalidValue(static_cast<int>(3));
 311   ImageView       imageView3 = ImageView::New();
 312   imageView3.SetProperty(Control::Property::BACKGROUND, invalidValue);
 313   imageView3.SetProperty(ImageView::Property::IMAGE, invalidValue);
 314
 315   application.GetScene().Add(imageView1);
 316   application.GetScene().Add(imageView2);
 317   application.GetScene().Add(imageView3);
 318
 319   application.SendNotification();
 320   application.Render();
 321
 322   DALI_TEST_EQUALS(imageView1.GetRendererCount(), 0u, TEST_LOCATION);
 323   DALI_TEST_EQUALS(imageView2.GetRendererCount(), 0u, TEST_LOCATION);
 324   DALI_TEST_EQUALS(imageView3.GetRendererCount(), 0u, TEST_LOCATION);
 325
 326   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "0");
 327   END_TEST;
 328 }
 329
 330 int UtcDaliDebugRenderingGetVisual4(void)
 331 {
 332   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "1");
 333   ToolkitTestApplication application;
 334   tet_infoline("UtcDaliDebugRenderingGetVisual4: Request visual with empty URL and empty Array");
 335
 336   VisualFactory factory = VisualFactory::Get();
 337   DALI_TEST_CHECK(factory);
 338
 339   // Test that image visual with null string don't make visual
 340   for(auto type : {DevelVisual::IMAGE, DevelVisual::ANIMATED_IMAGE, DevelVisual::SVG, DevelVisual::N_PATCH, DevelVisual::ANIMATED_VECTOR_IMAGE})
 341   {
 342     Dali::Property::Map map;
 343     map[Toolkit::Visual::Property::TYPE] = type;
 344     map[ImageVisual::Property::URL]      = "";
 345     Visual::Base emptyVisual             = factory.CreateVisual(map);
 346     DALI_TEST_CHECK(emptyVisual);
 347     TestDebugVisual(application.GetScene(), emptyVisual, Visual::WIREFRAME, Vector2::ZERO);
 348
 349     tet_infoline("Check that GetVisualObject returns the actual WireframeVisual");
 350     Toolkit::Internal::Visual::Base& visualImpl = GetImplementation(emptyVisual).GetVisualObject();
 351     DALI_TEST_CHECK(dynamic_cast<Toolkit::Internal::WireframeVisual*>(&visualImpl));
 352
 353     tet_infoline("Compare the returned emptyVisual with the visual implementation, should be the same");
 354     DALI_TEST_CHECK(emptyVisual.GetObjectPtr() == &visualImpl);
 355   }
 356
 357   // Test that image visual with empty array don't make visual
 358   for(auto type : {Visual::IMAGE, Visual::ANIMATED_IMAGE})
 359   {
 360     Dali::Property::Map   map;
 361     Dali::Property::Array emptyArray;
 362     map[Toolkit::Visual::Property::TYPE] = type;
 363     map[ImageVisual::Property::URL]      = emptyArray;
 364     Visual::Base emptyVisual             = factory.CreateVisual(map);
 365     DALI_TEST_CHECK(emptyVisual);
 366     TestDebugVisual(application.GetScene(), emptyVisual, Visual::WIREFRAME, Vector2::ZERO);
 367
 368     tet_infoline("Check that GetVisualObject returns the actual WireframeVisual");
 369     Toolkit::Internal::Visual::Base& visualImpl = GetImplementation(emptyVisual).GetVisualObject();
 370     DALI_TEST_CHECK(dynamic_cast<Toolkit::Internal::WireframeVisual*>(&visualImpl));
 371
 372     tet_infoline("Compare the returned emptyVisual with the visual implementation, should be the same");
 373     DALI_TEST_CHECK(emptyVisual.GetObjectPtr() == &visualImpl);
 374   }
 375
 376   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "0");
 377   END_TEST;
 378 }
 379
 380 int UtcDaliDebugRenderingGetVisualObject01(void)
 381 {
 382   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "1");
 383   ToolkitTestApplication application;
 384
 385   VisualFactory factory = VisualFactory::Get();
 386   DALI_TEST_CHECK(factory);
 387
 388   tet_infoline("Create a TextVisual when debugging is enabled, thus creating a proxy Wireframe Visual");
 389
 390   Dali::Property::Map map;
 391   map[Toolkit::Visual::Property::TYPE] = Visual::TEXT;
 392   map[TextVisual::Property::TEXT]      = "Hello";
 393
 394   Visual::Base textVisual = factory.CreateVisual(map);
 395   DALI_TEST_CHECK(textVisual);
 396
 397   tet_infoline("Check that GetVisualObject returns the actual TextVisual");
 398   Toolkit::Internal::Visual::Base& visualImpl = GetImplementation(textVisual).GetVisualObject();
 399   DALI_TEST_CHECK(dynamic_cast<Toolkit::Internal::TextVisual*>(&visualImpl));
 400
 401   tet_infoline("Compare the returned TextVisual with the visual implementation, should differ");
 402   DALI_TEST_CHECK(textVisual.GetObjectPtr() != &visualImpl);
 403
 404   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "0");
 405   END_TEST;
 406 }
 407
 408 int UtcDaliDebugRenderingGetVisualObject02(void)
 409 {
 410   ToolkitTestApplication application;
 411
 412   VisualFactory factory = VisualFactory::Get();
 413   DALI_TEST_CHECK(factory);
 414
 415   tet_infoline("Create a TextVisual without debugging enabled, thus no proxy Wireframe Visual");
 416
 417   Dali::Property::Map map;
 418   map[Toolkit::Visual::Property::TYPE] = Visual::TEXT;
 419   map[TextVisual::Property::TEXT]      = "Hello";
 420
 421   Visual::Base textVisual = factory.CreateVisual(map);
 422   DALI_TEST_CHECK(textVisual);
 423
 424   tet_infoline("Check that GetVisualObject returns the actual TextVisual");
 425   Toolkit::Internal::Visual::Base& visualImpl = GetImplementation(textVisual).GetVisualObject();
 426   DALI_TEST_CHECK(dynamic_cast<Toolkit::Internal::TextVisual*>(&visualImpl));
 427
 428   tet_infoline("Compare the returned TextVisual with the visual implementation, should be the same");
 429   DALI_TEST_CHECK(textVisual.GetObjectPtr() == &visualImpl);
 430
 431   END_TEST;
 432 }
 433
 434 int UtcDaliDebugRenderingGetVisualObject03(void)
 435 {
 436   ToolkitTestApplication application;
 437
 438   VisualFactory factory = VisualFactory::Get();
 439   DALI_TEST_CHECK(factory);
 440
 441   tet_infoline("Create a WireframeVisual without debugging enabled, thus no proxy Wireframe Visual either");
 442
 443   Dali::Property::Map map;
 444   map[Toolkit::Visual::Property::TYPE] = Visual::WIREFRAME;
 445
 446   Visual::Base textVisual = factory.CreateVisual(map);
 447   DALI_TEST_CHECK(textVisual);
 448
 449   tet_infoline("Check that GetVisualObject returns the WireframeVisual");
 450   Toolkit::Internal::Visual::Base& visualImpl = GetImplementation(textVisual).GetVisualObject();
 451   DALI_TEST_CHECK(dynamic_cast<Toolkit::Internal::WireframeVisual*>(&visualImpl));
 452
 453   tet_infoline("Compare the returned Visual with the visual implementation, should be the same");
 454   DALI_TEST_CHECK(textVisual.GetObjectPtr() == &visualImpl);
 455
 456   END_TEST;
 457 }
 458
 459 int UtcDaliDebugRenderingRenderText(void)
 460 {
 461   EnvironmentVariable::SetTestEnvironmentVariable(DALI_DEBUG_RENDERING, "1");
 462   ToolkitTestApplication application;
 463   tet_infoline("Ensure we can render text when in debug mode");
 464
 465   try
 466   {
 467     Toolkit::TextLabel label = TextLabel::New("Hello");
 468     application.GetScene().Add(label);
 469     DALI_TEST_CHECK(true);
 470   }
 471   catch(...)
 472   {
 473     DALI_TEST_CHECK(false);
 474   }
 475
 476   END_TEST;
 477 }