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