Update automated tests
[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-toolkit / utc-Dali-ImageVisual.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 #include <vector>
20
21 #include <dali-toolkit-test-suite-utils.h>
22
23 #include <toolkit-environment-variable.h>
24 #include <toolkit-event-thread-callback.h>
25 #include <toolkit-timer.h>
26
27 #include <dali-toolkit/dali-toolkit.h>
28 #include <dali-toolkit/devel-api/controls/control-devel.h>
29 #include <dali-toolkit/devel-api/image-loader/texture-manager.h>
30 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
31 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
32 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
33 #include <dali-toolkit/public-api/image-loader/image-url.h>
34 #include <dali-toolkit/public-api/image-loader/image.h>
35
36 #include "dummy-control.h"
37 #include "test-encoded-image-buffer.h"
38 #include "test-native-image-source.h"
39
40 using namespace Dali;
41 using namespace Dali::Toolkit;
42
43 void dali_image_visual_startup(void)
44 {
45   test_return_value = TET_UNDEF;
46 }
47
48 void dali_image_visual_cleanup(void)
49 {
50   test_return_value = TET_PASS;
51 }
52
53 namespace
54 {
55 const char* TEST_IMAGE_FILE_NAME          = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
56 const char* TEST_BROKEN_IMAGE_FILE_NAME   = TEST_RESOURCE_DIR "/a-random-nonimage.jpg";
57 const char* TEST_LARGE_IMAGE_FILE_NAME    = TEST_RESOURCE_DIR "/tbcol.png";
58 const char* TEST_SMALL_IMAGE_FILE_NAME    = TEST_RESOURCE_DIR "/icon-edit.png";
59 const char* TEST_REMOTE_IMAGE_FILE_NAME   = "https://www.tizen.org/sites/all/themes/tizen_theme/logo.png";
60 const char* TEST_INVALID_FILE_NAME        = TEST_RESOURCE_DIR "/invalid.jpg";
61 const char* TEST_REMOTE_INVALID_FILE_NAME = "https://www.tizen.org/invalid.png";
62 const char* TEST_MASK_IMAGE_FILE_NAME     = TEST_RESOURCE_DIR "/mask.png";
63 const char* TEST_ROTATED_IMAGE            = TEST_RESOURCE_DIR "/keyboard-Landscape.jpg";
64 const char* TEST_YUV420_IMAGE_FILE_NAME   = TEST_RESOURCE_DIR "/gallery-small-1-yuv420.jpg";
65 const char* TEST_N_PATCH_IMAGE_FILE_NAME  = TEST_RESOURCE_DIR "/heartsframe.9.png";
66
67 constexpr auto LOAD_IMAGE_YUV_PLANES_ENV         = "DALI_LOAD_IMAGE_YUV_PLANES";
68 constexpr auto ENABLE_DECODE_JPEG_TO_YUV_420_ENV = "DALI_ENABLE_DECODE_JPEG_TO_YUV_420";
69
70 bool             gResourceReadySignalFired = false;
71 std::vector<int> gReadyIds                 = {};
72 void             ResourceReadySignal(Control control)
73 {
74   gResourceReadySignalFired = true;
75   gReadyIds.push_back(control.GetProperty<int>(Actor::Property::ID));
76 }
77 void ClearReadyIds()
78 {
79   gReadyIds.clear();
80 }
81
82 Actor CreateActorWithImageVisual(const Property::Map& map)
83 {
84   VisualFactory     factory   = VisualFactory::Get();
85   DummyControl      actor     = DummyControl::New();
86   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
87   Visual::Base      visual    = factory.CreateVisual(map);
88   DALI_TEST_CHECK(visual);
89   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
90   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
91   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
92   return actor;
93 }
94
95 Visual::Base CreateVisualWithPolicy(const char* url, Property::Index key, const Property::Value& value)
96 {
97   VisualFactory factory = VisualFactory::Get();
98
99   Property::Map propertyMap;
100   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
101   propertyMap.Insert(ImageVisual::Property::URL, url);
102   propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
103   propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
104   propertyMap.Insert(key, value);
105
106   return factory.CreateVisual(propertyMap);
107 }
108
109 } // namespace
110
111 void TestVisualRender(ToolkitTestApplication&      application,
112                       DummyControl&                actor,
113                       Visual::Base&                visual,
114                       std::size_t                  expectedSamplers = 0,
115                       ImageDimensions              imageDimensions  = ImageDimensions(),
116                       Integration::ResourcePointer resourcePtr      = Integration::ResourcePointer())
117 {
118   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
119   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
120
121   if(resourcePtr)
122   {
123     // set the image size, for test case, this needs to be set before loading started
124     application.GetPlatform().SetClosestImageSize(Vector2(imageDimensions.GetWidth(), imageDimensions.GetHeight()));
125   }
126
127   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
128   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
129
130   application.GetScene().Add(actor);
131
132   application.SendNotification(); // Send messages to update
133   application.Render();           // process update and render
134   application.SendNotification(); // process any signals to event
135
136   if(resourcePtr)
137   {
138     DALI_TEST_EQUALS(application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceSynchronouslyFunc), true, TEST_LOCATION);
139   }
140
141   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
142 }
143
144 static void TestMixColor(Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor)
145 {
146   Property::Map map;
147   visual.CreatePropertyMap(map);
148   Property::Value* value = map.Find(mixColorIndex);
149   DALI_TEST_CHECK(value);
150   Vector3 mixColor1;
151   DALI_TEST_CHECK(value->Get(mixColor1));
152   DALI_TEST_EQUALS(mixColor1, Vector3(testColor), 0.001, TEST_LOCATION);
153
154   value = map.Find(Visual::Property::MIX_COLOR);
155   DALI_TEST_CHECK(value);
156   Vector4 mixColor2;
157   DALI_TEST_CHECK(value->Get(mixColor2));
158   DALI_TEST_EQUALS(mixColor2, testColor, 0.001, TEST_LOCATION);
159
160   value = map.Find(Visual::Property::OPACITY);
161   DALI_TEST_CHECK(value);
162   float opacity;
163   DALI_TEST_CHECK(value->Get(opacity));
164   DALI_TEST_EQUALS(opacity, testColor.a, 0.001, TEST_LOCATION);
165 }
166
167 int UtcDaliImageVisualPropertyMap(void)
168 {
169   ToolkitTestApplication application;
170   tet_infoline("Request image visual with a Property::Map");
171
172   VisualFactory factory = VisualFactory::Get();
173   DALI_TEST_CHECK(factory);
174   factory.SetPreMultiplyOnLoad(true);
175
176   Property::Map propertyMap;
177   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
178   propertyMap.Insert(ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME);
179
180   Visual::Base visual = factory.CreateVisual(propertyMap);
181   DALI_TEST_CHECK(visual);
182
183   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
184   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
185
186   TestGlAbstraction& gl           = application.GetGlAbstraction();
187   TraceCallStack&    textureTrace = gl.GetTextureTrace();
188   textureTrace.Enable(true);
189
190   DummyControl      actor     = DummyControl::New();
191   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
192   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
193
194   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
195   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
196
197   application.GetScene().Add(actor);
198   application.SendNotification();
199   application.Render();
200
201   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
202
203   application.SendNotification();
204   application.Render();
205
206   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
207   auto renderer           = actor.GetRendererAt(0);
208   auto preMultipliedIndex = renderer.GetPropertyIndex("preMultipliedAlpha");
209   DALI_TEST_CHECK(preMultipliedIndex != Property::INVALID_INDEX);
210   auto preMultipliedAlpha  = renderer.GetProperty<float>(preMultipliedIndex);
211   auto preMultipliedAlpha2 = renderer.GetProperty<bool>(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
212   DALI_TEST_EQUALS(preMultipliedAlpha, 1.0f, TEST_LOCATION);
213   DALI_TEST_EQUALS(preMultipliedAlpha2, true, TEST_LOCATION);
214   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
215
216   application.GetScene().Remove(actor);
217   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
218
219   END_TEST;
220 }
221
222 int UtcDaliImageVisualNoPremultipliedAlpha01(void)
223 {
224   ToolkitTestApplication application;
225   tet_infoline("Request image visual without pre-multiplied alpha");
226
227   VisualFactory factory = VisualFactory::Get();
228   DALI_TEST_CHECK(factory);
229   factory.SetPreMultiplyOnLoad(false);
230
231   Property::Map propertyMap;
232   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
233   propertyMap.Insert(ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME);
234
235   Visual::Base visual = factory.CreateVisual(propertyMap);
236   DALI_TEST_CHECK(visual);
237
238   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
239   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
240
241   TestGlAbstraction& gl           = application.GetGlAbstraction();
242   TraceCallStack&    textureTrace = gl.GetTextureTrace();
243   textureTrace.Enable(true);
244
245   DummyControl      actor     = DummyControl::New();
246   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
247   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
248
249   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
250   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
251
252   application.GetScene().Add(actor);
253   application.SendNotification();
254   application.Render();
255
256   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
257
258   application.SendNotification();
259   application.Render();
260
261   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
262   auto renderer           = actor.GetRendererAt(0);
263   auto preMultipliedIndex = renderer.GetPropertyIndex("preMultipliedAlpha");
264   DALI_TEST_CHECK(preMultipliedIndex != Property::INVALID_INDEX);
265   auto preMultipliedAlpha  = renderer.GetProperty<bool>(preMultipliedIndex);
266   auto preMultipliedAlpha2 = renderer.GetProperty<bool>(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
267
268   DALI_TEST_EQUALS(preMultipliedAlpha, false, TEST_LOCATION);
269   DALI_TEST_EQUALS(preMultipliedAlpha2, false, TEST_LOCATION);
270
271   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
272
273   application.GetScene().Remove(actor);
274   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
275
276   END_TEST;
277 }
278
279 int UtcDaliImageVisualNoPremultipliedAlpha02(void)
280 {
281   ToolkitTestApplication application;
282   tet_infoline("Request image visual with no alpha channel");
283
284   VisualFactory factory = VisualFactory::Get();
285   DALI_TEST_CHECK(factory);
286
287   Property::Map propertyMap;
288   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
289   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
290
291   Visual::Base visual = factory.CreateVisual(propertyMap);
292   DALI_TEST_CHECK(visual);
293
294   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
295   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
296
297   TestGlAbstraction& gl           = application.GetGlAbstraction();
298   TraceCallStack&    textureTrace = gl.GetTextureTrace();
299   textureTrace.Enable(true);
300
301   DummyControl      actor     = DummyControl::New();
302   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
303   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
304
305   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
306   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
307
308   application.GetScene().Add(actor);
309   application.SendNotification();
310   application.Render();
311
312   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
313
314   application.SendNotification();
315   application.Render();
316
317   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
318   auto renderer           = actor.GetRendererAt(0);
319   auto preMultipliedIndex = renderer.GetPropertyIndex("preMultipliedAlpha");
320   DALI_TEST_CHECK(preMultipliedIndex != Property::INVALID_INDEX);
321   auto preMultipliedAlpha  = renderer.GetProperty<bool>(preMultipliedIndex);
322   auto preMultipliedAlpha2 = renderer.GetProperty<bool>(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
323
324   DALI_TEST_EQUALS(preMultipliedAlpha, false, TEST_LOCATION);
325   DALI_TEST_EQUALS(preMultipliedAlpha2, false, TEST_LOCATION);
326
327   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
328
329   int srcFactorRgb    = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
330   int destFactorRgb   = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
331   int srcFactorAlpha  = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
332   int destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
333   DALI_TEST_CHECK(srcFactorRgb == BlendFactor::SRC_ALPHA);
334   DALI_TEST_CHECK(destFactorRgb == BlendFactor::ONE_MINUS_SRC_ALPHA);
335   DALI_TEST_CHECK(srcFactorAlpha == BlendFactor::ONE);
336   DALI_TEST_CHECK(destFactorAlpha == BlendFactor::ONE_MINUS_SRC_ALPHA);
337
338   textureTrace.Reset();
339
340   // Make a new visual with the same image
341   Visual::Base newVisual = factory.CreateVisual(propertyMap);
342   DALI_TEST_CHECK(newVisual);
343
344   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
345   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
346
347   DummyControl      newActor     = DummyControl::New();
348   DummyControlImpl& newDummyImpl = static_cast<DummyControlImpl&>(newActor.GetImplementation());
349   newDummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, newVisual);
350
351   newActor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
352   DALI_TEST_EQUALS(newActor.GetRendererCount(), 0u, TEST_LOCATION);
353
354   application.GetScene().Add(newActor);
355
356   application.SendNotification();
357   application.Render();
358
359   DALI_TEST_EQUALS(newActor.GetRendererCount(), 1u, TEST_LOCATION);
360   auto newRenderer   = newActor.GetRendererAt(0);
361   preMultipliedIndex = newRenderer.GetPropertyIndex("preMultipliedAlpha");
362   DALI_TEST_CHECK(preMultipliedIndex != Property::INVALID_INDEX);
363   preMultipliedAlpha  = newRenderer.GetProperty<bool>(preMultipliedIndex);
364   preMultipliedAlpha2 = newRenderer.GetProperty<bool>(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
365
366   DALI_TEST_EQUALS(preMultipliedAlpha, false, TEST_LOCATION);
367   DALI_TEST_EQUALS(preMultipliedAlpha2, false, TEST_LOCATION);
368
369   srcFactorRgb    = newRenderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
370   destFactorRgb   = newRenderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
371   srcFactorAlpha  = newRenderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
372   destFactorAlpha = newRenderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
373   DALI_TEST_CHECK(srcFactorRgb == BlendFactor::SRC_ALPHA);
374   DALI_TEST_CHECK(destFactorRgb == BlendFactor::ONE_MINUS_SRC_ALPHA);
375   DALI_TEST_CHECK(srcFactorAlpha == BlendFactor::ONE);
376   DALI_TEST_CHECK(destFactorAlpha == BlendFactor::ONE_MINUS_SRC_ALPHA);
377
378   application.GetScene().Remove(actor);
379   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
380
381   END_TEST;
382 }
383
384 int UtcDaliImageVisualRemoteImageLoad(void)
385 {
386   ToolkitTestApplication application;
387   tet_infoline("Request remote image visual with a Property::Map");
388
389   VisualFactory factory = VisualFactory::Get();
390   DALI_TEST_CHECK(factory);
391
392   Property::Map propertyMap;
393   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
394   propertyMap.Insert(ImageVisual::Property::URL, TEST_REMOTE_IMAGE_FILE_NAME);
395
396   Visual::Base visual = factory.CreateVisual(propertyMap);
397   DALI_TEST_CHECK(visual);
398
399   TestGlAbstraction& gl           = application.GetGlAbstraction();
400   TraceCallStack&    textureTrace = gl.GetTextureTrace();
401   textureTrace.Enable(true);
402
403   DummyControl      actor     = DummyControl::New();
404   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
405   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
406
407   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
408   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
409
410   application.GetScene().Add(actor);
411   application.SendNotification();
412
413   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
414
415   application.SendNotification();
416   application.Render();
417
418   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
419   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
420
421   application.GetScene().Remove(actor);
422   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
423
424   END_TEST;
425 }
426
427 int UtcDaliImageVisualWithNativeImage(void)
428 {
429   ToolkitTestApplication application;
430   tet_infoline("Use Native Image as url");
431
432   NativeImageSourcePtr nativeImageSource = NativeImageSource::New(500, 500, NativeImageSource::COLOR_DEPTH_DEFAULT);
433   ImageUrl             imageUrl          = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
434   std::string          url               = imageUrl.GetUrl();
435
436   VisualFactory factory = VisualFactory::Get();
437   DALI_TEST_CHECK(factory);
438
439   Property::Map propertyMap;
440   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
441   propertyMap.Insert(ImageVisual::Property::URL, url);
442
443   Visual::Base visual = factory.CreateVisual(propertyMap);
444   DALI_TEST_CHECK(visual);
445
446   DummyControl      actor     = DummyControl::New();
447   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
448   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
449
450   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
451
452   application.GetScene().Add(actor);
453
454   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
455
456   Renderer renderer = actor.GetRendererAt(0);
457   Shader   shader   = renderer.GetShader();
458
459   Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
460   DALI_TEST_CHECK(value.GetType() == Property::MAP);
461   const Property::Map* outMap         = value.GetMap();
462   std::string          fragmentShader = (*outMap)["fragment"].Get<std::string>();
463
464   const char* fragmentPrefix = Dali::NativeImageSourceTest::GetCustomFragmentPrefix();
465   size_t      pos            = fragmentShader.find(fragmentPrefix);
466
467   DALI_TEST_EQUALS(pos != std::string::npos, true, TEST_LOCATION);
468
469   END_TEST;
470 }
471
472 int UtcDaliImageVisualWithNativeImageCustomShader(void)
473 {
474   ToolkitTestApplication application;
475   tet_infoline("Use Native Image as url and Use custom shader");
476
477   NativeImageSourcePtr nativeImageSource = NativeImageSource::New(500, 500, NativeImageSource::COLOR_DEPTH_DEFAULT);
478   ImageUrl             imageUrl          = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
479   std::string          url               = imageUrl.GetUrl();
480
481   VisualFactory factory = VisualFactory::Get();
482   DALI_TEST_CHECK(factory);
483
484   Property::Map     propertyMap;
485   Property::Map     shaderMap;
486   const std::string customVertexShaderSource                    = "Foobar";
487   const std::string customFragmentShaderSource                  = "Foobar";
488   shaderMap[Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = customFragmentShaderSource;
489   shaderMap[Toolkit::Visual::Shader::Property::VERTEX_SHADER]   = customVertexShaderSource;
490
491   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
492   propertyMap.Insert(Toolkit::Visual::Property::SHADER, shaderMap);
493   propertyMap.Insert(ImageVisual::Property::URL, url);
494
495   Visual::Base visual = factory.CreateVisual(propertyMap);
496   DALI_TEST_CHECK(visual);
497
498   DummyControl      actor     = DummyControl::New();
499   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
500   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
501
502   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
503   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
504
505   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
506
507   application.GetScene().Add(actor);
508
509   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
510
511   application.SendNotification();
512   application.Render(16);
513
514   Renderer renderer = actor.GetRendererAt(0);
515   Shader   shader   = renderer.GetShader();
516
517   Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
518   DALI_TEST_CHECK(value.GetType() == Property::MAP);
519   const Property::Map* outMap               = value.GetMap();
520   std::string          fragmentShaderSource = (*outMap)["fragment"].Get<std::string>();
521   std::string          vertexShaderSource   = (*outMap)["vertex"].Get<std::string>();
522
523   // Compare vertex shader is equal
524   DALI_TEST_EQUALS(customVertexShaderSource, vertexShaderSource, TEST_LOCATION);
525
526   // Check fragment shader changed
527   const char* fragmentPrefix = Dali::NativeImageSourceTest::GetCustomFragmentPrefix();
528   size_t      pos            = fragmentShaderSource.find(fragmentPrefix);
529
530   DALI_TEST_EQUALS(pos != std::string::npos, true, TEST_LOCATION);
531
532   DALI_TEST_EQUALS(std::string(fragmentPrefix) + customFragmentShaderSource, fragmentShaderSource, TEST_LOCATION);
533
534   END_TEST;
535 }
536
537 int UtcDaliImageVisualWithNativeImageRemoved(void)
538 {
539   ToolkitTestApplication application;
540   tet_infoline("Use Native Image as url");
541
542   TestGlAbstraction& gl           = application.GetGlAbstraction();
543   TraceCallStack&    textureTrace = gl.GetTextureTrace();
544   textureTrace.Enable(true);
545
546   NativeImageSourcePtr nativeImageSource = NativeImageSource::New(500, 500, NativeImageSource::COLOR_DEPTH_DEFAULT);
547   ImageUrl             imageUrl          = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
548   std::string          url               = imageUrl.GetUrl();
549
550   VisualFactory factory = VisualFactory::Get();
551   DALI_TEST_CHECK(factory);
552
553   Property::Map propertyMap;
554   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
555   propertyMap.Insert(ImageVisual::Property::URL, url);
556
557   Visual::Base visual = factory.CreateVisual(propertyMap);
558   DALI_TEST_CHECK(visual);
559
560   DummyControl      actor     = DummyControl::New();
561   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
562   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
563
564   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
565
566   application.GetScene().Add(actor);
567   application.SendNotification();
568   application.Render();
569
570   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
571   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
572
573   tet_infoline("No delete texture because reference count is not zero");
574   imageUrl.Reset();
575   application.GetScene().Remove(actor);
576   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL);
577   application.SendNotification();
578   application.Render();
579
580   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
581   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
582
583   tet_infoline("Delete texture because reference count is zero");
584   visual.Reset();
585   application.SendNotification();
586   application.Render();
587
588   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION);
589
590   END_TEST;
591 }
592
593 int UtcDaliImageVisualWithEncodedImageBuffer(void)
594 {
595   ToolkitTestApplication application;
596   tet_infoline("Use Encoded Image Buffer as url");
597
598   EncodedImageBuffer rawBuffer = ConvertFileToEncodedImageBuffer(TEST_LARGE_IMAGE_FILE_NAME);
599   ImageUrl           url       = Dali::Toolkit::Image::GenerateUrl(rawBuffer);
600
601   VisualFactory factory = VisualFactory::Get();
602   DALI_TEST_CHECK(factory);
603
604   Property::Map propertyMap;
605   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
606   propertyMap.Insert(ImageVisual::Property::URL, url.GetUrl());
607
608   Visual::Base visual = factory.CreateVisual(propertyMap);
609   DALI_TEST_CHECK(visual);
610
611   TestGlAbstraction& gl           = application.GetGlAbstraction();
612   TraceCallStack&    textureTrace = gl.GetTextureTrace();
613   textureTrace.Enable(true);
614
615   DummyControl      actor     = DummyControl::New();
616   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
617   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
618
619   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
620   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
621
622   application.GetScene().Add(actor);
623   application.SendNotification();
624
625   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
626
627   application.SendNotification();
628   application.Render();
629
630   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
631   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
632
633   application.GetScene().Remove(actor);
634   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
635
636   END_TEST;
637 }
638
639 int UtcDaliImageVisualWithEncodedImageBufferRemoved(void)
640 {
641   ToolkitTestApplication application;
642   tet_infoline("Use Encoded Image Buffer as url");
643
644   TestGlAbstraction& gl           = application.GetGlAbstraction();
645   TraceCallStack&    textureTrace = gl.GetTextureTrace();
646   textureTrace.Enable(true);
647
648   EncodedImageBuffer rawBuffer = ConvertFileToEncodedImageBuffer(TEST_LARGE_IMAGE_FILE_NAME);
649   ImageUrl           imageUrl  = Dali::Toolkit::Image::GenerateUrl(rawBuffer);
650   std::string        url       = imageUrl.GetUrl();
651
652   VisualFactory factory = VisualFactory::Get();
653   DALI_TEST_CHECK(factory);
654
655   Property::Map propertyMap;
656   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
657   propertyMap.Insert(ImageVisual::Property::URL, url);
658
659   Visual::Base visual = factory.CreateVisual(propertyMap);
660   DALI_TEST_CHECK(visual);
661
662   DummyControl      actor     = DummyControl::New();
663   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
664   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
665
666   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
667
668   application.GetScene().Add(actor);
669   application.SendNotification();
670
671   // Wait for decode buffer and make texture.
672   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
673
674   application.SendNotification();
675   application.Render();
676
677   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
678   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
679
680   tet_infoline("Delete texture because there is no actor to use decoded texture");
681   imageUrl.Reset();
682   application.GetScene().Remove(actor);
683   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL);
684   application.SendNotification();
685   application.Render();
686
687   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
688   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION);
689
690   END_TEST;
691 }
692
693 int UtcDaliImageVisualTextureReuse1(void)
694 {
695   ToolkitTestApplication application;
696   tet_infoline("Request remote image visual with a Property::Map; request a second visual with the same property map - should reuse texture");
697
698   Property::Map propertyMap;
699   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
700   propertyMap.Insert(ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME);
701   propertyMap.Insert(ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DETACHED);
702
703   TestGlAbstraction& gl           = application.GetGlAbstraction();
704   TraceCallStack&    textureTrace = gl.GetTextureTrace();
705   textureTrace.Enable(true);
706   TraceCallStack& drawTrace = gl.GetDrawTrace();
707   drawTrace.Enable(true);
708
709   Actor actor = CreateActorWithImageVisual(propertyMap);
710   application.GetScene().Add(actor);
711   application.SendNotification();
712
713   // Wait for image to load
714   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
715
716   application.SendNotification();
717   application.Render();
718
719   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
720   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
721   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
722   DALI_TEST_EQUALS(drawTrace.FindMethod("DrawArrays"), true, TEST_LOCATION);
723   textureTrace.Reset();
724   drawTrace.Reset();
725
726   Actor actor2 = CreateActorWithImageVisual(propertyMap);
727   application.GetScene().Add(actor2);
728
729   application.SendNotification(); // Send messages to update
730   application.Render();           // process update and render
731   application.SendNotification(); // process any signals to event
732
733   DALI_TEST_EQUALS(actor2.GetRendererCount(), 1u, TEST_LOCATION);
734
735   // Testing for texture re-use in gl side is not relevant - we are not using actual graphics
736   // backend here, but test graphics backend.
737   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
738   DALI_TEST_EQUALS(drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION);
739
740   tet_infoline("Test that removing 1 actor doesn't delete the texture\n");
741
742   application.GetScene().Remove(actor);
743   application.SendNotification();
744   application.Render();
745
746   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
747   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
748
749   tet_infoline("Test that removing last actor does delete the texture\n");
750
751   application.GetScene().Remove(actor2); // Detaches remaining ImageVisual
752   application.SendNotification();
753   application.Render();
754
755   DALI_TEST_CHECK(actor2.GetRendererCount() == 0u);
756   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION);
757
758   END_TEST;
759 }
760
761 int UtcDaliImageVisualTextureReuse2(void)
762 {
763   ToolkitTestApplication application;
764   tet_infoline("Request remote image visual with a Property::Map; request a second visual with the same url but different property map - should create new texture");
765
766   Property::Map propertyMap;
767   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
768   propertyMap.Insert(ImageVisual::Property::URL, TEST_REMOTE_IMAGE_FILE_NAME);
769
770   TestGlAbstraction& gl           = application.GetGlAbstraction();
771   TraceCallStack&    textureTrace = gl.GetTextureTrace();
772   textureTrace.Enable(true);
773   TraceCallStack& drawTrace = gl.GetDrawTrace();
774   drawTrace.Enable(true);
775
776   Actor actor = CreateActorWithImageVisual(propertyMap);
777   application.GetScene().Add(actor);
778   application.SendNotification();
779
780   // Wait for image to load
781   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
782
783   application.SendNotification();
784   application.Render();
785
786   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
787   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
788   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
789   DALI_TEST_EQUALS(drawTrace.FindMethod("DrawArrays"), true, TEST_LOCATION);
790   textureTrace.Reset();
791   drawTrace.Reset();
792
793   propertyMap.Insert(ImageVisual::Property::SAMPLING_MODE, Dali::SamplingMode::NEAREST);
794   propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 100);
795   propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 100);
796   Actor actor2 = CreateActorWithImageVisual(propertyMap);
797   application.GetScene().Add(actor2);
798
799   application.SendNotification();
800
801   // Wait for image to load
802   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
803
804   application.SendNotification();
805   application.Render();
806
807   DALI_TEST_EQUALS(actor2.GetRendererCount(), 1u, TEST_LOCATION);
808
809   tet_infoline(
810     "Test that 2 draw calls occur with 1 new texture gen/bind, i.e. both "
811     "renderers are using different textures\n");
812
813   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
814   DALI_TEST_EQUALS(drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION);
815   TraceCallStack::NamedParams tex1;
816   tex1["texture"] << 1;
817   TraceCallStack::NamedParams tex2;
818   tex2["texture"] << 2;
819   DALI_TEST_EQUALS(textureTrace.FindMethodAndParams("BindTexture", tex1), true, TEST_LOCATION);
820   DALI_TEST_EQUALS(textureTrace.FindMethodAndParams("BindTexture", tex2), true, TEST_LOCATION);
821
822   tet_infoline("Test that removing 1 actor deletes it's texture\n");
823
824   application.GetScene().Remove(actor);
825   application.SendNotification();
826   application.Render();
827
828   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
829   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION);
830
831   tet_infoline("Test that removing last actor deletes it's texture\n");
832
833   application.GetScene().Remove(actor2);
834   application.SendNotification();
835   application.Render();
836
837   DALI_TEST_CHECK(actor2.GetRendererCount() == 0u);
838   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 2, TEST_LOCATION);
839
840   END_TEST;
841 }
842
843 int UtcDaliImageVisualCustomWrapModePixelArea(void)
844 {
845   ToolkitTestApplication application;
846   tet_infoline("Request image visual with a Property::Map, test custom wrap mode and pixel area with atlasing");
847
848   static std::vector<UniformData> customUniforms =
849     {
850       UniformData("pixelArea", Property::Type::VECTOR4),
851       UniformData("wrapMode", Property::Type::VECTOR2),
852     };
853
854   TestGraphicsController& graphics = application.GetGraphicsController();
855   graphics.AddCustomUniforms(customUniforms);
856
857   VisualFactory factory = VisualFactory::Get();
858   DALI_TEST_CHECK(factory);
859
860   // Test wrap mode with atlasing. Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
861   const int     width  = 34;
862   const int     height = 34;
863   const Vector4 pixelArea(-0.5f, -0.5f, 2.f, 2.f);
864
865   Property::Map propertyMap;
866   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
867   propertyMap.Insert(ImageVisual::Property::URL, TEST_SMALL_IMAGE_FILE_NAME);
868   propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, width);
869   propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, height);
870   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
871   propertyMap.Insert(ImageVisual::Property::PIXEL_AREA, pixelArea);
872   propertyMap.Insert(ImageVisual::Property::WRAP_MODE_U, WrapMode::MIRRORED_REPEAT);
873   propertyMap.Insert(ImageVisual::Property::WRAP_MODE_V, WrapMode::REPEAT);
874   propertyMap.Insert(ImageVisual::Property::ATLASING, true);
875
876   Visual::Base visual = factory.CreateVisual(propertyMap);
877   DALI_TEST_CHECK(visual);
878
879   TestGlAbstraction& gl           = application.GetGlAbstraction();
880   TraceCallStack&    textureTrace = gl.GetTextureTrace();
881   textureTrace.Enable(true);
882   TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
883   texParameterTrace.Enable(true);
884
885   DummyControl      actor     = DummyControl::New();
886   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
887   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
888   actor.SetProperty(Actor::Property::SIZE, Vector2(2000, 2000));
889   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
890   application.GetScene().Add(actor);
891
892   // loading started
893   application.SendNotification();
894   application.Render();
895
896   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
897
898   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
899
900   // WITH atlasing, the wrapping is handled manually in shader, so the following gl function should not be called
901   std::stringstream out;
902   out << std::hex << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_S << ", " << GL_MIRRORED_REPEAT;
903   DALI_TEST_CHECK(!texParameterTrace.FindMethodAndParams("TexParameteri", out.str()));
904   out.str("");
905   out << std::hex << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_T << ", " << GL_REPEAT;
906   DALI_TEST_CHECK(!texParameterTrace.FindMethodAndParams("TexParameteri", out.str()));
907
908   // test the uniforms which used to handle the wrap mode
909   Renderer renderer = actor.GetRendererAt(0u);
910   DALI_TEST_CHECK(renderer);
911
912   Property::Value pixelAreaValue = renderer.GetProperty(renderer.GetPropertyIndex("pixelArea"));
913   DALI_TEST_EQUALS(pixelAreaValue.Get<Vector4>(), pixelArea, TEST_LOCATION);
914   Vector4 pixelAreaUniform;
915   DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("pixelArea", pixelAreaUniform));
916   DALI_TEST_EQUALS(pixelArea, pixelAreaUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION);
917
918   Property::Value wrapModeValue = renderer.GetProperty(renderer.GetPropertyIndex("wrapMode"));
919   Vector2         wrapMode(WrapMode::MIRRORED_REPEAT - 1, WrapMode::REPEAT - 1);
920   DALI_TEST_EQUALS(wrapModeValue.Get<Vector2>(), wrapMode, TEST_LOCATION);
921   Vector2 wrapModeUniform;
922   DALI_TEST_CHECK(gl.GetUniformValue<Vector2>("wrapMode", wrapModeUniform));
923   DALI_TEST_EQUALS(wrapMode, wrapModeUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION);
924
925   actor.Unparent();
926   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
927
928   END_TEST;
929 }
930
931 int UtcDaliImageVisualCustomWrapModeNoAtlas(void)
932 {
933   ToolkitTestApplication application;
934   tet_infoline("Request image visual with a Property::Map, test custom wrap mode and pixel area without atlasing");
935
936   static std::vector<UniformData> customUniforms =
937     {
938       UniformData("pixelArea", Property::Type::VECTOR4),
939     };
940
941   TestGraphicsController& graphics = application.GetGraphicsController();
942   graphics.AddCustomUniforms(customUniforms);
943
944   VisualFactory factory = VisualFactory::Get();
945   DALI_TEST_CHECK(factory);
946
947   // Test wrap mode without atlasing. Image with a size bigger than 512*512 will NOT be uploaded as a part of the atlas.
948   const int     width  = 600;
949   const int     height = 600;
950   const Vector4 pixelArea(-0.5f, -0.5f, 2.f, 2.f);
951
952   Property::Map propertyMap;
953   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
954   propertyMap.Insert(ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME);
955   propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, width);
956   propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, height);
957   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
958   propertyMap.Insert(ImageVisual::Property::PIXEL_AREA, pixelArea);
959   propertyMap.Insert(ImageVisual::Property::WRAP_MODE_U, WrapMode::MIRRORED_REPEAT);
960   propertyMap.Insert(ImageVisual::Property::WRAP_MODE_V, WrapMode::REPEAT);
961
962   Visual::Base visual = factory.CreateVisual(propertyMap);
963   DALI_TEST_CHECK(visual);
964
965   TestGlAbstraction& gl           = application.GetGlAbstraction();
966   TraceCallStack&    textureTrace = gl.GetTextureTrace();
967   textureTrace.Enable(true);
968   textureTrace.EnableLogging(true);
969   TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
970   texParameterTrace.Enable(true);
971   texParameterTrace.EnableLogging(true);
972
973   DummyControl      actor     = DummyControl::New();
974   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
975   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
976   actor.SetProperty(Actor::Property::SIZE, Vector2(2000, 2000));
977   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
978   application.GetScene().Add(actor);
979
980   // loading started
981   application.SendNotification();
982   application.Render();
983   application.SendNotification();
984
985   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
986
987   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
988
989   // WITHOUT atlasing, the wrapping is handled by setting gl texture parameters
990   std::stringstream out;
991   out << std::hex << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_S << ", " << GL_MIRRORED_REPEAT;
992   DALI_TEST_CHECK(texParameterTrace.FindMethodAndParams("TexParameteri", out.str()));
993   out.str("");
994   out << std::hex << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_T << ", " << GL_REPEAT;
995   DALI_TEST_CHECK(texParameterTrace.FindMethodAndParams("TexParameteri", out.str()));
996
997   // test the uniforms which used to handle the wrap mode
998   Renderer renderer = actor.GetRendererAt(0u);
999   DALI_TEST_CHECK(renderer);
1000
1001   Property::Value pixelAreaValue = renderer.GetProperty(renderer.GetPropertyIndex("pixelArea"));
1002   DALI_TEST_EQUALS(pixelAreaValue.Get<Vector4>(), pixelArea, TEST_LOCATION);
1003   Vector4 pixelAreaUniform;
1004   DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("pixelArea", pixelAreaUniform));
1005   DALI_TEST_EQUALS(pixelArea, pixelAreaUniform, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1006
1007   Property::Index wrapModeIndex = renderer.GetPropertyIndex("wrapMode");
1008   DALI_TEST_CHECK(wrapModeIndex == Property::INVALID_INDEX);
1009
1010   actor.Unparent();
1011   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
1012
1013   END_TEST;
1014 }
1015
1016 int UtcDaliImageVisualAnimateMixColor(void)
1017 {
1018   ToolkitTestApplication application;
1019   tet_infoline("Animate mix color");
1020
1021   static std::vector<UniformData> customUniforms =
1022     {
1023       UniformData("mixColor", Property::Type::VECTOR3),
1024     };
1025
1026   TestGraphicsController& graphics = application.GetGraphicsController();
1027   graphics.AddCustomUniforms(customUniforms);
1028
1029   application.GetPlatform().SetClosestImageSize(Vector2(100, 100));
1030
1031   VisualFactory factory = VisualFactory::Get();
1032   Property::Map propertyMap;
1033   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
1034   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
1035   propertyMap.Insert("mixColor", Color::BLUE);
1036   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
1037   Visual::Base visual = factory.CreateVisual(propertyMap);
1038
1039   DummyControl        actor     = DummyControl::New(true);
1040   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1041   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1042
1043   actor.SetProperty(Actor::Property::SIZE, Vector2(2000, 2000));
1044   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1045   actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
1046   application.GetScene().Add(actor);
1047
1048   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1049
1050   Renderer renderer = actor.GetRendererAt(0);
1051
1052   // @todo Should we add API to make this code work again?
1053   // Property::Index index = renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1054
1055   Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
1056   DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1057
1058   const Vector4 TARGET_MIX_COLOR(1.0f, 0.0f, 0.0f, 0.5f);
1059
1060   Property::Map map;
1061   map["target"]       = "testVisual";
1062   map["property"]     = "mixColor";
1063   map["initialValue"] = Color::MAGENTA;
1064   map["targetValue"]  = TARGET_MIX_COLOR;
1065   map["animator"]     = Property::Map()
1066                       .Add("alphaFunction", "LINEAR")
1067                       .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1068
1069   Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1070
1071   Animation animation = dummyImpl.CreateTransition(transition);
1072
1073   animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
1074   animation.Play();
1075
1076   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1077   glAbstraction.EnableEnableDisableCallTrace(true);
1078   TraceCallStack&    glEnableStack = glAbstraction.GetEnableDisableTrace();
1079   std::ostringstream blendStr;
1080   blendStr << std::hex << GL_BLEND;
1081
1082   application.SendNotification();
1083   application.Render(0);     // Ensure animation starts
1084   application.Render(2000u); // Halfway point
1085   Vector3 testColor(1.0f, 0.0f, 0.5f);
1086
1087   // uColor.a should be actor's alpha * mixColor.a.
1088   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, 0.75f)), true, TEST_LOCATION);
1089   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
1090
1091   DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
1092
1093   glEnableStack.Reset();
1094
1095   application.SendNotification();
1096   application.Render(2000u);
1097
1098   application.SendNotification();
1099   application.Render();
1100   application.SendNotification();
1101
1102   DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
1103   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, 0.5f)), true, TEST_LOCATION);
1104   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
1105
1106   // (Don't test for caching of capabilities, toolkit uses Test graphics backend, not actual backend)
1107
1108   TestMixColor(visual, Visual::Property::MIX_COLOR, TARGET_MIX_COLOR);
1109
1110   END_TEST;
1111 }
1112
1113 int UtcDaliImageVisualAnimateOpacity(void)
1114 {
1115   ToolkitTestApplication application;
1116   tet_infoline("Animate image visual opacity");
1117
1118   application.GetPlatform().SetClosestImageSize(Vector2(100, 100));
1119
1120   VisualFactory factory = VisualFactory::Get();
1121   Property::Map propertyMap;
1122   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
1123   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
1124   propertyMap.Insert("opacity", 0.5f);
1125   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
1126   Visual::Base visual = factory.CreateVisual(propertyMap);
1127
1128   DummyControl        actor     = DummyControl::New(true);
1129   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1130   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1131
1132   actor.SetProperty(Actor::Property::SIZE, Vector2(2000, 2000));
1133   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1134   actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
1135   application.GetScene().Add(actor);
1136
1137   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1138
1139   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1140   glAbstraction.EnableEnableDisableCallTrace(true);
1141   TraceCallStack&    glEnableStack = glAbstraction.GetEnableDisableTrace();
1142   std::ostringstream blendStr;
1143   blendStr << std::hex << GL_BLEND;
1144
1145   application.SendNotification();
1146   application.Render();
1147
1148   DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
1149
1150   {
1151     tet_infoline("Test that the opacity can be increased to full via animation, and that the blend mode is set appropriately at the start and end of the animation.");
1152
1153     Property::Map map;
1154     map["target"]      = "testVisual";
1155     map["property"]    = "opacity";
1156     map["targetValue"] = 1.0f;
1157     map["animator"]    = Property::Map()
1158                         .Add("alphaFunction", "LINEAR")
1159                         .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1160
1161     Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1162     Animation                     animation  = dummyImpl.CreateTransition(transition);
1163     animation.Play();
1164
1165     glEnableStack.Reset();
1166
1167     application.SendNotification();
1168     application.Render(0);          // Ensure animation starts
1169     application.Render(2000u);      // Halfway point through animation
1170     application.SendNotification(); // Handle any signals
1171
1172     Vector4 color;
1173     DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", color));
1174     DALI_TEST_EQUALS(color.a, 0.75f, TEST_LOCATION);
1175
1176     application.Render(2001u);      // end
1177     application.SendNotification(); // ensure animation finished signal is sent
1178
1179     DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", color));
1180     DALI_TEST_EQUALS(color.a, 1.0f, TEST_LOCATION);
1181
1182     // (Don't test for caching of capabilities, toolkit uses Test graphics backend, not actual backend)
1183     DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
1184   }
1185
1186   {
1187     tet_infoline("Test that the opacity can be reduced via animation, and that the blend mode is set appropriately at the start and end of the animation.");
1188
1189     Property::Map map;
1190     map["target"]      = "testVisual";
1191     map["property"]    = Visual::Property::OPACITY;
1192     map["targetValue"] = 0.1f;
1193     map["animator"]    = Property::Map()
1194                         .Add("alphaFunction", "LINEAR")
1195                         .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1196
1197     Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1198     Animation                     animation  = dummyImpl.CreateTransition(transition);
1199     animation.Play();
1200
1201     glEnableStack.Reset();
1202
1203     application.SendNotification();
1204     application.Render(0);     // Ensure animation starts
1205     application.Render(2000u); // Halfway point
1206     application.SendNotification();
1207
1208     Vector4 color;
1209     DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", color));
1210     DALI_TEST_EQUALS(color.a, 0.55f, TEST_LOCATION);
1211
1212     DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
1213
1214     glEnableStack.Reset();
1215
1216     application.Render(2016u); // end
1217     application.SendNotification();
1218
1219     DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", color));
1220     DALI_TEST_EQUALS(color.a, 0.1f, TEST_LOCATION);
1221
1222     // (Don't test for caching of capabilities, toolkit uses Test graphics backend, not actual backend)
1223     DALI_TEST_CHECK(!glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
1224   }
1225
1226   END_TEST;
1227 }
1228
1229 int UtcDaliImageVisualAnimateOpacity02(void)
1230 {
1231   ToolkitTestApplication application;
1232   tet_infoline("Animate image visual opacity");
1233
1234   application.GetPlatform().SetClosestImageSize(Vector2(100, 100));
1235
1236   VisualFactory factory = VisualFactory::Get();
1237   Property::Map propertyMap;
1238   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
1239   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
1240   propertyMap.Insert("opacity", 0.5f);
1241   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
1242   Visual::Base visual = factory.CreateVisual(propertyMap);
1243
1244   DummyControl        actor     = DummyControl::New(true);
1245   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1246   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1247
1248   actor.SetProperty(Actor::Property::SIZE, Vector2(2000, 2000));
1249   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1250   actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
1251
1252   tet_infoline("Test that the opacity doesn't animate when actor not staged");
1253
1254   Property::Array array;
1255
1256   Property::Map map;
1257   map["target"]       = "testVisual";
1258   map["property"]     = "opacity";
1259   map["initialValue"] = 0.0f;
1260   map["targetValue"]  = 1.0f;
1261   map["animator"]     = Property::Map()
1262                       .Add("alphaFunction", "LINEAR")
1263                       .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1264
1265   Property::Map map2;
1266   map2["target"]      = "testVisual";
1267   map2["property"]    = "size";
1268   map2["targetValue"] = Vector2(1.0f, 1.0f);
1269
1270   array.Add(map).Add(map2);
1271
1272   Dali::Toolkit::TransitionData transition = TransitionData::New(array);
1273   Animation                     animation  = dummyImpl.CreateTransition(transition);
1274
1275   application.GetScene().Add(actor);
1276   application.SendNotification();
1277   application.Render(0); // Ensure animation starts
1278
1279   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1280
1281   Renderer        renderer       = actor.GetRendererAt(0);
1282   Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
1283   DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1284
1285   animation = dummyImpl.CreateTransition(transition);
1286   animation.Play();
1287
1288   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1289   glAbstraction.EnableEnableDisableCallTrace(true);
1290   TraceCallStack&    glEnableStack = glAbstraction.GetEnableDisableTrace();
1291   std::ostringstream blendStr;
1292   blendStr << std::hex << GL_BLEND;
1293
1294   application.SendNotification();
1295   application.Render(0);          // Ensure animation starts
1296   application.Render(2000u);      // Halfway point through animation
1297   application.SendNotification(); // Handle any signals
1298
1299   DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
1300
1301   Vector4 color;
1302   DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", color));
1303   DALI_TEST_EQUALS(color.a, 0.5f, TEST_LOCATION);
1304
1305   glEnableStack.Reset();
1306
1307   application.Render(2001u);      // end
1308   application.SendNotification(); // ensure animation finished signal is sent
1309
1310   DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", color));
1311   DALI_TEST_EQUALS(color.a, 1.0f, TEST_LOCATION);
1312
1313   DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
1314
1315   END_TEST;
1316 }
1317
1318 int UtcDaliImageVisualAnimatePixelArea(void)
1319 {
1320   ToolkitTestApplication application;
1321   tet_infoline("ImageVisual animate pixel area");
1322
1323   static std::vector<UniformData> customUniforms =
1324     {
1325       UniformData("pixelArea", Property::Type::VECTOR4),
1326     };
1327
1328   TestGraphicsController& graphics = application.GetGraphicsController();
1329   graphics.AddCustomUniforms(customUniforms);
1330
1331   application.GetPlatform().SetClosestImageSize(Vector2(100, 100));
1332
1333   VisualFactory factory = VisualFactory::Get();
1334   Property::Map propertyMap;
1335   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
1336   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
1337   propertyMap.Insert("mixColor", Color::BLUE);
1338   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
1339   Visual::Base visual = factory.CreateVisual(propertyMap);
1340
1341   DummyControl        actor     = DummyControl::New(true);
1342   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1343   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
1344
1345   actor.SetProperty(Actor::Property::SIZE, Vector2(2000, 2000));
1346   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1347   actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
1348   application.GetScene().Add(actor);
1349
1350   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1351
1352   Renderer renderer = actor.GetRendererAt(0);
1353   // @todo Implement this feature?
1354   //Property::Index index = renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1355   //tet_infoline("Test that the renderer has the mixColor property");
1356   //DALI_TEST_CHECK( index != Property::INVALID_INDEX );
1357
1358   // TransitionData only takes string keys
1359   Property::Map map;
1360   map["target"]       = "testVisual";
1361   map["property"]     = "pixelArea";
1362   map["initialValue"] = Vector4(0, 0, 0, 1);
1363   map["targetValue"]  = Vector4(0, 0, 1, 1); // Animate width from zero to full
1364   map["animator"]     = Property::Map()
1365                       .Add("alphaFunction", "LINEAR")
1366                       .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1367
1368   Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1369
1370   Animation animation = dummyImpl.CreateTransition(transition);
1371   animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
1372   animation.Play();
1373
1374   application.SendNotification();
1375   application.Render(0);     // Ensure animation starts
1376   application.Render(2000u); // Halfway point
1377
1378   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("pixelArea", Vector4(0.0f, 0.0f, 0.5f, 1.0f)), true, TEST_LOCATION);
1379
1380   application.Render(2000u); // End of animation
1381
1382   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("pixelArea", Vector4(0.0f, 0.0f, 1.0f, 1.0f)), true, TEST_LOCATION);
1383
1384   END_TEST;
1385 }
1386
1387 int UtcDaliImageVisualTextureCancelRemoteLoad(void)
1388 {
1389   ToolkitTestApplication application;
1390   tet_infoline("Request remote image visual, then destroy visual to cancel load");
1391
1392   Property::Map propertyMap;
1393   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1394   propertyMap.Insert(ImageVisual::Property::URL, TEST_REMOTE_IMAGE_FILE_NAME);
1395
1396   TestGlAbstraction& gl           = application.GetGlAbstraction();
1397   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1398   textureTrace.Enable(true);
1399   TraceCallStack& drawTrace = gl.GetDrawTrace();
1400   drawTrace.Enable(true);
1401
1402   Actor actor = CreateActorWithImageVisual(propertyMap);
1403   application.GetScene().Add(actor);
1404   application.SendNotification();
1405
1406   application.GetScene().Remove(actor);
1407   application.SendNotification();
1408
1409   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1410   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
1411   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), false, TEST_LOCATION);
1412   DALI_TEST_EQUALS(drawTrace.FindMethod("DrawArrays"), false, TEST_LOCATION);
1413
1414   END_TEST;
1415 }
1416
1417 int UtcDaliImageVisualTextureCancelAsyncLoad(void)
1418 {
1419   ToolkitTestApplication application;
1420   tet_infoline("Load image asynchronously, cancel loading, then load again");
1421
1422   VisualFactory factory = VisualFactory::Get();
1423   DALI_TEST_CHECK(factory);
1424
1425   Property::Map propertyMap;
1426   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1427   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
1428
1429   Visual::Base visual = factory.CreateVisual(propertyMap);
1430   DALI_TEST_CHECK(visual);
1431
1432   TestGlAbstraction& gl           = application.GetGlAbstraction();
1433   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1434   textureTrace.Enable(true);
1435   TraceCallStack& drawTrace = gl.GetDrawTrace();
1436   drawTrace.Enable(true);
1437
1438   DummyControl      actor     = DummyControl::New();
1439   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1440   dummyImpl.RegisterVisual(Control::Property::BACKGROUND, visual);
1441
1442   application.GetScene().Add(actor);
1443
1444   // Cancel loading
1445   application.GetScene().Remove(actor);
1446
1447   application.GetScene().Add(actor);
1448
1449   // Create another visual with the same image
1450   visual = factory.CreateVisual(propertyMap);
1451   DALI_TEST_CHECK(visual);
1452
1453   dummyImpl.RegisterVisual(Control::Property::BACKGROUND, visual);
1454
1455   application.SendNotification();
1456   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1457
1458   application.SendNotification();
1459   application.Render();
1460
1461   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1462   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
1463   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1464   DALI_TEST_EQUALS(drawTrace.FindMethod("DrawArrays"), true, TEST_LOCATION);
1465
1466   END_TEST;
1467 }
1468
1469 int UtcDaliImageVisualSetInvalidAsyncImage(void)
1470 {
1471   ToolkitTestApplication application;
1472   tet_infoline("Request image visual with invalid images - should draw broken.png");
1473
1474   VisualFactory factory = VisualFactory::Get();
1475   DALI_TEST_CHECK(factory);
1476
1477   Property::Map propertyMap;
1478   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1479   propertyMap.Insert(ImageVisual::Property::URL, TEST_INVALID_FILE_NAME);
1480
1481   Visual::Base visual = factory.CreateVisual(propertyMap);
1482   DALI_TEST_CHECK(visual);
1483
1484   TestGlAbstraction& gl           = application.GetGlAbstraction();
1485   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1486   textureTrace.Enable(true);
1487
1488   DummyControl      actor     = DummyControl::New();
1489   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1490   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
1491
1492   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1493   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1494
1495   application.GetScene().Add(actor);
1496
1497   application.SendNotification();
1498   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1499
1500   application.SendNotification();
1501   application.Render();
1502
1503   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1504   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1505
1506   application.GetScene().Remove(actor);
1507   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
1508
1509   END_TEST;
1510 }
1511
1512 int UtcDaliImageVisualSetInvalidSyncImage(void)
1513 {
1514   ToolkitTestApplication application;
1515   tet_infoline("Request image visual with invalid images - should draw broken.png");
1516
1517   VisualFactory factory = VisualFactory::Get();
1518   DALI_TEST_CHECK(factory);
1519
1520   Property::Map propertyMap;
1521   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1522   propertyMap.Insert(ImageVisual::Property::URL, TEST_INVALID_FILE_NAME);
1523   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
1524
1525   Visual::Base visual = factory.CreateVisual(propertyMap);
1526   DALI_TEST_CHECK(visual);
1527
1528   TestGlAbstraction& gl           = application.GetGlAbstraction();
1529   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1530   textureTrace.Enable(true);
1531
1532   DummyControl      actor     = DummyControl::New();
1533   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1534   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
1535
1536   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1537   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1538
1539   application.GetScene().Add(actor);
1540
1541   application.SendNotification();
1542   application.Render();
1543
1544   // Check resource status
1545   Visual::ResourceStatus status = actor.GetVisualResourceStatus(Control::CONTROL_PROPERTY_END_INDEX + 1);
1546   DALI_TEST_EQUALS(status, Visual::ResourceStatus::FAILED, TEST_LOCATION);
1547
1548   // The broken image should be shown.
1549   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1550   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1551
1552   application.GetScene().Remove(actor);
1553   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
1554
1555   END_TEST;
1556 }
1557
1558 int UtcDaliImageVisualSetInvalidRemoteImage(void)
1559 {
1560   ToolkitTestApplication application;
1561   tet_infoline("Request image visual with invalid images - should draw broken.png");
1562
1563   VisualFactory factory = VisualFactory::Get();
1564   DALI_TEST_CHECK(factory);
1565
1566   // Local invalid file, asynchronous loading
1567   Property::Map propertyMap;
1568   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1569   propertyMap.Insert(ImageVisual::Property::URL, TEST_REMOTE_INVALID_FILE_NAME);
1570
1571   Visual::Base visual = factory.CreateVisual(propertyMap);
1572   DALI_TEST_CHECK(visual);
1573
1574   TestGlAbstraction& gl           = application.GetGlAbstraction();
1575   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1576   textureTrace.Enable(true);
1577
1578   DummyControl      actor     = DummyControl::New();
1579   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1580   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
1581
1582   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1583   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1584
1585   application.GetScene().Add(actor);
1586
1587   application.SendNotification();
1588   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
1589
1590   application.SendNotification();
1591   application.Render();
1592
1593   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1594   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1595
1596   application.GetScene().Remove(actor);
1597   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
1598
1599   END_TEST;
1600 }
1601
1602 int UtcDaliImageVisualAlphaMask01(void)
1603 {
1604   ToolkitTestApplication application;
1605   tet_infoline("Request image visual with a Property::Map containing an Alpha mask");
1606
1607   VisualFactory factory = VisualFactory::Get();
1608   DALI_TEST_CHECK(factory);
1609
1610   Property::Map propertyMap;
1611   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1612   propertyMap.Insert(ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME);
1613   propertyMap.Insert(ImageVisual::Property::ALPHA_MASK_URL, TEST_MASK_IMAGE_FILE_NAME);
1614
1615   Visual::Base visual = factory.CreateVisual(propertyMap);
1616   DALI_TEST_CHECK(visual);
1617
1618   Property::Map testMap;
1619   visual.CreatePropertyMap(testMap);
1620   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::ALPHA_MASK_URL), Property::Value(TEST_MASK_IMAGE_FILE_NAME), TEST_LOCATION);
1621
1622   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1623   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1624
1625   TestGlAbstraction& gl           = application.GetGlAbstraction();
1626   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1627   textureTrace.Enable(true);
1628
1629   DummyControl      actor     = DummyControl::New();
1630   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1631   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
1632
1633   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1634   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1635   DALI_TEST_EQUALS(actor.IsResourceReady(), false, TEST_LOCATION);
1636
1637   application.GetScene().Add(actor);
1638   application.SendNotification();
1639   application.Render();
1640
1641   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
1642
1643   application.SendNotification();
1644   application.Render();
1645
1646   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1647   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1648   DALI_TEST_EQUALS(actor.IsResourceReady(), true, TEST_LOCATION);
1649
1650   dummyImpl.UnregisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1);
1651   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1652
1653   END_TEST;
1654 }
1655
1656 int UtcDaliImageVisualAlphaMask02(void)
1657 {
1658   ToolkitTestApplication application;
1659   tet_infoline("Request image visual with a Property::Map containing an Alpha mask for GPU");
1660
1661   VisualFactory factory = VisualFactory::Get();
1662   DALI_TEST_CHECK(factory);
1663
1664   Property::Map propertyMap;
1665   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1666   propertyMap.Insert(ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME);
1667   propertyMap.Insert(ImageVisual::Property::ALPHA_MASK_URL, TEST_MASK_IMAGE_FILE_NAME);
1668   propertyMap.Insert(DevelImageVisual::Property::MASKING_TYPE, DevelImageVisual::MaskingType::MASKING_ON_RENDERING);
1669
1670   Visual::Base visual = factory.CreateVisual(propertyMap);
1671   DALI_TEST_CHECK(visual);
1672
1673   Property::Map testMap;
1674   visual.CreatePropertyMap(testMap);
1675   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::ALPHA_MASK_URL), Property::Value(TEST_MASK_IMAGE_FILE_NAME), TEST_LOCATION);
1676   DALI_TEST_EQUALS(*testMap.Find(DevelImageVisual::Property::MASKING_TYPE), Property::Value(DevelImageVisual::MaskingType::MASKING_ON_RENDERING), TEST_LOCATION);
1677
1678   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1679   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1680
1681   TestGlAbstraction& gl           = application.GetGlAbstraction();
1682   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1683   textureTrace.Enable(true);
1684
1685   DummyControl      actor     = DummyControl::New();
1686   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1687   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
1688
1689   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1690   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1691   DALI_TEST_EQUALS(actor.IsResourceReady(), false, TEST_LOCATION);
1692
1693   application.GetScene().Add(actor);
1694   application.SendNotification();
1695   application.Render();
1696
1697   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
1698
1699   application.SendNotification();
1700   application.Render();
1701
1702   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1703   Renderer   renderer = actor.GetRendererAt(0u);
1704   TextureSet textures = renderer.GetTextures();
1705   DALI_TEST_CHECK(textures);
1706   DALI_TEST_EQUALS(textures.GetTextureCount(), 2u, TEST_LOCATION);
1707
1708   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1709   DALI_TEST_EQUALS(actor.IsResourceReady(), true, TEST_LOCATION);
1710
1711   dummyImpl.UnregisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1);
1712   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1713
1714   END_TEST;
1715 }
1716
1717 int UtcDaliImageVisualAlphaMask03(void)
1718 {
1719   ToolkitTestApplication application;
1720   tet_infoline("Request image visual with a Property::Map containing an Alpha mask for GPU with fail case");
1721
1722   VisualFactory factory = VisualFactory::Get();
1723   DALI_TEST_CHECK(factory);
1724
1725   Property::Map propertyMap;
1726   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1727   propertyMap.Insert(ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME);
1728   propertyMap.Insert(ImageVisual::Property::ALPHA_MASK_URL, "dummy_path");
1729   propertyMap.Insert(DevelImageVisual::Property::MASKING_TYPE, DevelImageVisual::MaskingType::MASKING_ON_RENDERING);
1730
1731   Visual::Base visual = factory.CreateVisual(propertyMap);
1732   DALI_TEST_CHECK(visual);
1733
1734   Property::Map testMap;
1735   visual.CreatePropertyMap(testMap);
1736
1737   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1738   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1739
1740   TestGlAbstraction& gl           = application.GetGlAbstraction();
1741   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1742   textureTrace.Enable(true);
1743
1744   DummyControl      actor     = DummyControl::New();
1745   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1746   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
1747
1748   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1749   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1750   DALI_TEST_EQUALS(actor.IsResourceReady(), false, TEST_LOCATION);
1751
1752   application.GetScene().Add(actor);
1753   application.SendNotification();
1754   application.Render();
1755
1756   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
1757
1758   application.SendNotification();
1759   application.Render();
1760
1761   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1762   Renderer   renderer = actor.GetRendererAt(0u);
1763   TextureSet textures = renderer.GetTextures();
1764   DALI_TEST_CHECK(textures);
1765   DALI_TEST_EQUALS(textures.GetTextureCount(), 1u, TEST_LOCATION);
1766
1767   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1768   DALI_TEST_EQUALS(actor.IsResourceReady(), true, TEST_LOCATION);
1769
1770   dummyImpl.UnregisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1);
1771   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1772
1773   END_TEST;
1774 }
1775
1776 int UtcDaliImageVisualSynchronousLoadAlphaMask01(void)
1777 {
1778   ToolkitTestApplication application;
1779   tet_infoline("Request image visual with a Property::Map containing an Alpha mask with synchronous loading");
1780
1781   VisualFactory factory = VisualFactory::Get();
1782   DALI_TEST_CHECK(factory);
1783
1784   Property::Map propertyMap;
1785   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1786   propertyMap.Insert(ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME);
1787   propertyMap.Insert(ImageVisual::Property::ALPHA_MASK_URL, TEST_MASK_IMAGE_FILE_NAME);
1788   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
1789
1790   Visual::Base visual = factory.CreateVisual(propertyMap);
1791   DALI_TEST_CHECK(visual);
1792
1793   Property::Map testMap;
1794   visual.CreatePropertyMap(testMap);
1795   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::ALPHA_MASK_URL), Property::Value(TEST_MASK_IMAGE_FILE_NAME), TEST_LOCATION);
1796
1797   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1798   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1799
1800   TestGlAbstraction& gl           = application.GetGlAbstraction();
1801   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1802   textureTrace.Enable(true);
1803
1804   DummyControl      actor     = DummyControl::New();
1805   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1806   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
1807
1808   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1809   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1810   DALI_TEST_EQUALS(actor.IsResourceReady(), false, TEST_LOCATION);
1811
1812   application.GetScene().Add(actor);
1813
1814   // Do not wait for any EventThreadTrigger in synchronous alpha mask.
1815
1816   application.SendNotification();
1817   application.Render();
1818
1819   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1820   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1821   DALI_TEST_EQUALS(actor.IsResourceReady(), true, TEST_LOCATION);
1822
1823   dummyImpl.UnregisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1);
1824   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1825
1826   END_TEST;
1827 }
1828
1829 int UtcDaliImageVisualSynchronousLoadAlphaMask02(void)
1830 {
1831   ToolkitTestApplication application;
1832   tet_infoline("Request image visual with a Property::Map containing an Alpha mask for GPU with synchronous loading");
1833
1834   VisualFactory factory = VisualFactory::Get();
1835   DALI_TEST_CHECK(factory);
1836
1837   Property::Map propertyMap;
1838   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1839   propertyMap.Insert(ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME);
1840   propertyMap.Insert(ImageVisual::Property::ALPHA_MASK_URL, TEST_MASK_IMAGE_FILE_NAME);
1841   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
1842   propertyMap.Insert(DevelImageVisual::Property::MASKING_TYPE, DevelImageVisual::MaskingType::MASKING_ON_RENDERING);
1843
1844   Visual::Base visual = factory.CreateVisual(propertyMap);
1845   DALI_TEST_CHECK(visual);
1846
1847   Property::Map testMap;
1848   visual.CreatePropertyMap(testMap);
1849   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::ALPHA_MASK_URL), Property::Value(TEST_MASK_IMAGE_FILE_NAME), TEST_LOCATION);
1850
1851   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1852   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1853
1854   TestGlAbstraction& gl           = application.GetGlAbstraction();
1855   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1856   textureTrace.Enable(true);
1857
1858   DummyControl      actor     = DummyControl::New();
1859   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1860   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
1861
1862   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1863   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1864   DALI_TEST_EQUALS(actor.IsResourceReady(), false, TEST_LOCATION);
1865
1866   application.GetScene().Add(actor);
1867
1868   // Do not wait for any EventThreadTrigger in synchronous alpha mask.
1869
1870   application.SendNotification();
1871   application.Render();
1872
1873   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1874   Renderer   renderer = actor.GetRendererAt(0u);
1875   TextureSet textures = renderer.GetTextures();
1876   DALI_TEST_CHECK(textures);
1877   DALI_TEST_EQUALS(textures.GetTextureCount(), 2u, TEST_LOCATION);
1878
1879   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1880   DALI_TEST_EQUALS(actor.IsResourceReady(), true, TEST_LOCATION);
1881
1882   dummyImpl.UnregisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1);
1883   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1884
1885   END_TEST;
1886 }
1887
1888 int UtcDaliImageVisualRemoteAlphaMask(void)
1889 {
1890   ToolkitTestApplication application;
1891   tet_infoline("Request image visual with a Property::Map containing an Alpha mask");
1892
1893   VisualFactory factory = VisualFactory::Get();
1894   DALI_TEST_CHECK(factory);
1895
1896   const std::string MASK_IMAGE = TEST_REMOTE_IMAGE_FILE_NAME;
1897
1898   Property::Map propertyMap;
1899   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1900   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
1901   propertyMap.Insert(ImageVisual::Property::ALPHA_MASK_URL, MASK_IMAGE);
1902
1903   Visual::Base visual = factory.CreateVisual(propertyMap);
1904   DALI_TEST_CHECK(visual);
1905
1906   Property::Map testMap;
1907   visual.CreatePropertyMap(testMap);
1908
1909   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::ALPHA_MASK_URL), Property::Value(MASK_IMAGE), TEST_LOCATION);
1910
1911   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1912   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1913
1914   TestGlAbstraction& gl           = application.GetGlAbstraction();
1915   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1916   textureTrace.Enable(true);
1917
1918   DummyControl      actor     = DummyControl::New();
1919   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1920   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
1921
1922   DALI_TEST_EQUALS(actor.IsResourceReady(), false, TEST_LOCATION);
1923
1924   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1925   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1926
1927   application.GetScene().Add(actor);
1928   application.SendNotification();
1929   application.Render();
1930
1931   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
1932
1933   application.SendNotification();
1934   application.Render();
1935
1936   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1937   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1938   DALI_TEST_EQUALS(actor.IsResourceReady(), true, TEST_LOCATION);
1939
1940   END_TEST;
1941 }
1942
1943 int UtcDaliImageVisualAlphaMaskCrop(void)
1944 {
1945   ToolkitTestApplication application;
1946   tet_infoline("Request image visual with an Alpha mask and scale/cropping");
1947
1948   VisualFactory factory = VisualFactory::Get();
1949   DALI_TEST_CHECK(factory);
1950
1951   Property::Map propertyMap;
1952   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
1953   propertyMap.Insert(ImageVisual::Property::URL, TEST_LARGE_IMAGE_FILE_NAME);
1954   propertyMap.Insert(ImageVisual::Property::ALPHA_MASK_URL, TEST_MASK_IMAGE_FILE_NAME);
1955   propertyMap.Insert(ImageVisual::Property::MASK_CONTENT_SCALE, 1.6f);
1956   propertyMap.Insert(ImageVisual::Property::CROP_TO_MASK, true);
1957
1958   Visual::Base visual = factory.CreateVisual(propertyMap);
1959   DALI_TEST_CHECK(visual);
1960
1961   Property::Map testMap;
1962   visual.CreatePropertyMap(testMap);
1963   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::ALPHA_MASK_URL), Property::Value(TEST_MASK_IMAGE_FILE_NAME), TEST_LOCATION);
1964   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::MASK_CONTENT_SCALE), Property::Value(1.6f), TEST_LOCATION);
1965   DALI_TEST_EQUALS(*testMap.Find(ImageVisual::Property::CROP_TO_MASK), Property::Value(true), TEST_LOCATION);
1966
1967   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
1968   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
1969
1970   TestGlAbstraction& gl           = application.GetGlAbstraction();
1971   TraceCallStack&    textureTrace = gl.GetTextureTrace();
1972   textureTrace.Enable(true);
1973
1974   DummyControl      actor     = DummyControl::New();
1975   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
1976   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
1977
1978   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
1979   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
1980   DALI_TEST_EQUALS(actor.IsResourceReady(), false, TEST_LOCATION);
1981
1982   application.GetScene().Add(actor);
1983   application.SendNotification();
1984   application.Render();
1985
1986   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
1987
1988   application.SendNotification();
1989   application.Render();
1990
1991   Vector2 size;
1992   visual.GetNaturalSize(size);
1993
1994   DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), 0.001f, TEST_LOCATION);
1995   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1996   DALI_TEST_EQUALS(textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION);
1997   DALI_TEST_EQUALS(actor.IsResourceReady(), true, TEST_LOCATION);
1998
1999   END_TEST;
2000 }
2001
2002 int UtcDaliImageVisualReleasePolicy01(void)
2003 {
2004   ToolkitTestApplication application;
2005   tet_infoline("UtcDaliImageVisualReleasePolicy01 Detached Policy, disabling visual with this policy deletes texture");
2006
2007   Visual::Base imageVisual = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DETACHED);
2008   DALI_TEST_CHECK(imageVisual);
2009
2010   // Set up debug trace
2011   TestGlAbstraction& gl           = application.GetGlAbstraction();
2012   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2013   textureTrace.Enable(true);
2014
2015   tet_infoline("Register visual with control and ensure it has the only handle");
2016   DummyControl        actor     = DummyControl::New(true);
2017   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2018   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
2019   imageVisual.Reset();
2020
2021   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2022
2023   application.SendNotification();
2024   application.Render(0);
2025   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2026   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2027
2028   application.GetScene().Add(actor);
2029
2030   // Wait for image to load
2031   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2032
2033   application.SendNotification();
2034   application.Render(0);
2035   // Test renderer and texture created
2036   tet_infoline("Confirm texture created");
2037   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2038   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2039
2040   tet_infoline("Disable visual causing the texture to be deleted");
2041   dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
2042
2043   application.SendNotification();
2044   application.Render(0);
2045   // Test renderer and textures removed.
2046   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2047   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION);
2048
2049   END_TEST;
2050 }
2051
2052 int UtcDaliImageVisualReleasePolicy02(void)
2053 {
2054   ToolkitTestApplication application;
2055   tet_infoline("UtcDaliImageVisualReleasePolicy02 Destroyed Policy, Texture should be deleted when visual destroyed");
2056
2057   Visual::Base imageVisual = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DESTROYED);
2058   DALI_TEST_CHECK(imageVisual);
2059
2060   // Setup debug trace
2061   TestGlAbstraction& gl           = application.GetGlAbstraction();
2062   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2063   textureTrace.Enable(true);
2064
2065   tet_infoline("Register visual with control and ensure it has the only handle");
2066   DummyControl        actor     = DummyControl::New(true);
2067   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2068   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
2069   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2070
2071   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2072
2073   application.SendNotification();
2074   application.Render(0);
2075   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2076   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2077
2078   application.GetScene().Add(actor);
2079
2080   // Wait for image to load
2081   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2082
2083   application.SendNotification();
2084   application.Render(0);
2085   // Test renderer and texture created
2086   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2087   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2088
2089   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
2090   tet_infoline("Destroy visual by UnRegistering visual with control, check renderer is destroyed");
2091   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL);
2092   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2093   application.SendNotification();
2094   application.Render();
2095
2096   // Test texture removed after visual destroyed.
2097   tet_infoline("Ensure texture is deleted after visual destroyed");
2098   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION);
2099
2100   END_TEST;
2101 }
2102
2103 int UtcDaliImageVisualReleasePolicy03(void)
2104 {
2105   ToolkitTestApplication application;
2106   tet_infoline("UtcDaliImageVisualReleasePolicy03 Never Policy, texture should not be deleted after visual destroyed");
2107
2108   Visual::Base imageVisual = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::NEVER);
2109   DALI_TEST_CHECK(imageVisual);
2110
2111   TestGlAbstraction& gl           = application.GetGlAbstraction();
2112   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2113   textureTrace.Enable(true);
2114
2115   tet_infoline("Register visual with control and ensure it has the only handle");
2116   DummyControl        actor     = DummyControl::New(true);
2117   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2118   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
2119   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2120
2121   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2122
2123   application.SendNotification();
2124   application.Render(0);
2125   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2126   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2127
2128   application.GetScene().Add(actor);
2129
2130   // Wait for image to load
2131   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2132
2133   application.SendNotification();
2134   application.Render(0);
2135   // Test renderer and texture created
2136   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2137   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2138
2139   tet_infoline("Destroy visual by UnRegistering visual with control, check renderer is destroyed");
2140   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
2141   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL);
2142   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2143   application.SendNotification();
2144   application.Render();
2145
2146   tet_infoline("Ensure texture is not deleted as policy is set to NEVER");
2147   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
2148
2149   END_TEST;
2150 }
2151
2152 int UtcDaliImageVisualReleasePolicy04(void)
2153 {
2154   ToolkitTestApplication application;
2155   tet_infoline("UtcDaliImageVisualReleasePolicy04 Two visuals with different policies sharing a texture");
2156
2157   tet_infoline("Create first visual with Never release policy");
2158   Visual::Base imageVisualNever = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::NEVER);
2159
2160   tet_infoline("Create second visual with Destroyed release policy");
2161   Visual::Base imageVisualDestroyed = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DESTROYED);
2162
2163   // Set up trace debug
2164   TestGlAbstraction& gl           = application.GetGlAbstraction();
2165   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2166   textureTrace.Enable(true);
2167
2168   tet_infoline("Register visuals with control and ensure it has the only handles");
2169   DummyControl        actor     = DummyControl::New(true);
2170   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2171   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisualNever);
2172   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, imageVisualDestroyed);
2173   imageVisualNever.Reset();     // reduce ref count so only the control keeps the visual alive.
2174   imageVisualDestroyed.Reset(); // reduce ref count so only the control keeps the visual alive.
2175
2176   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2177
2178   // Test initially zero renderers
2179   application.SendNotification();
2180   application.Render(0);
2181   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2182   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2183
2184   application.GetScene().Add(actor);
2185
2186   // Wait for image to load
2187   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2188
2189   application.SendNotification();
2190   application.Render(0);
2191   tet_infoline("Ensure a texture is created, shared amongst both visuals.  Each visual has its own renderer");
2192   DALI_TEST_EQUALS(actor.GetRendererCount(), 2u, TEST_LOCATION);
2193   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2194
2195   // Test renderer removed when visual destroyed
2196   DALI_TEST_CHECK(actor.GetRendererCount() == 2u);
2197   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL2); // TEST_VISUAL2 no longer requires the texture as release policy DESTROYED
2198   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
2199   application.SendNotification();
2200   application.Render();
2201
2202   // Test texture was not deleted as TEST_VISUAL release policy is NEVER so it is still required.
2203   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
2204
2205   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL);
2206   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2207   application.SendNotification();
2208   application.Render();
2209
2210   tet_infoline("Ensure a texture is not deleted as second visual used the NEVER release policy");
2211   // Test texture was not deleted as TEST_VISUAL release policy is NEVER so it is still required.
2212   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
2213
2214   END_TEST;
2215 }
2216
2217 int UtcDaliImageVisualReleasePolicy05(void)
2218 {
2219   ToolkitTestApplication application;
2220   tet_infoline("UtcDaliImageVisualReleasePolicy05 Testing settung by string currents correct enum");
2221
2222   VisualFactory factory = VisualFactory::Get();
2223
2224   Property::Map propertyMapNeverReleasePolicy;
2225   propertyMapNeverReleasePolicy.Insert(Visual::Property::TYPE, Visual::IMAGE);
2226   propertyMapNeverReleasePolicy.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
2227   propertyMapNeverReleasePolicy.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
2228   propertyMapNeverReleasePolicy.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
2229   propertyMapNeverReleasePolicy.Insert("releasePolicy", "never");
2230
2231   Visual::Base imageVisualNever = factory.CreateVisual(propertyMapNeverReleasePolicy);
2232
2233   Property::Map resultMap;
2234   imageVisualNever.CreatePropertyMap(resultMap);
2235   DALI_TEST_CHECK(!resultMap.Empty());
2236
2237   DALI_TEST_EQUALS((resultMap.Find(ImageVisual::Property::RELEASE_POLICY))->Get<int>(), (int)ImageVisual::ReleasePolicy::NEVER, TEST_LOCATION);
2238
2239   END_TEST;
2240 }
2241
2242 int UtcDaliImageVisualReleasePolicy06(void)
2243 {
2244   ToolkitTestApplication application;
2245   tet_infoline("UtcDaliImageVisualReleasePolicy06 Never Policy, texture should not be affected by Disabling and Enabling visual");
2246
2247   Visual::Base imageVisual = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::NEVER);
2248   DALI_TEST_CHECK(imageVisual);
2249
2250   TestGlAbstraction& gl           = application.GetGlAbstraction();
2251   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2252   textureTrace.Enable(true);
2253
2254   tet_infoline("Register visual with control and ensure it has the only handle");
2255   DummyControl        actor     = DummyControl::New(true);
2256   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2257   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
2258   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2259
2260   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2261
2262   application.SendNotification();
2263   application.Render(0);
2264   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2265   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2266
2267   application.GetScene().Add(actor);
2268
2269   // Wait for image to load
2270   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2271
2272   application.SendNotification();
2273   application.Render(0);
2274   // Test renderer and texture created
2275   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2276   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2277   textureTrace.Reset();
2278
2279   tet_infoline("Disable Visual and check texture not affected");
2280   dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
2281   application.SendNotification();
2282   application.Render(0);
2283   tet_infoline("Check renderer is destroyed when visual off stage");
2284   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2285   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
2286   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2287   textureTrace.Reset();
2288
2289   tet_infoline("Re-enable Visual and check texture not affected");
2290   dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
2291   application.SendNotification();
2292   application.Render(0);
2293   tet_infoline("Check texture not affected and renderer is destroyed when visual off stage");
2294   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
2295   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
2296   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2297
2298   END_TEST;
2299 }
2300
2301 int UtcDaliImageVisualReleasePolicy07(void)
2302 {
2303   ToolkitTestApplication application;
2304   tet_infoline("UtcDaliImageVisualReleasePolicy07 Two visuals with different policies sharing a texture DETACHED and DESTROYED");
2305
2306   tet_infoline("Create first visual with DESTROYED release policy");
2307   Visual::Base imageVisualDestroyed = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DESTROYED);
2308
2309   tet_infoline("Create second visual with DETACHED release policy");
2310   Visual::Base imageVisualDetached = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DETACHED);
2311
2312   // Set up trace debug
2313   TestGlAbstraction& gl           = application.GetGlAbstraction();
2314   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2315   textureTrace.Enable(true);
2316
2317   tet_infoline("Register visuals with control and ensure it has the only handles");
2318   DummyControl        actor     = DummyControl::New(true);
2319   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2320   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisualDestroyed);
2321   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, imageVisualDetached);
2322   imageVisualDestroyed.Reset(); // reduce ref count so only the control keeps the visual alive.
2323   imageVisualDetached.Reset();  // reduce ref count so only the control keeps the visual alive.
2324
2325   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2326
2327   // Test initially zero renderers
2328   application.SendNotification();
2329   application.Render(0);
2330   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2331   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2332
2333   application.GetScene().Add(actor);
2334
2335   // Wait for image to load
2336   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2337
2338   application.SendNotification();
2339   application.Render(0);
2340   tet_infoline("Ensure a texture is created, shared amongst both visuals.  Each visual has its own renderer");
2341   DALI_TEST_EQUALS(actor.GetRendererCount(), 2u, TEST_LOCATION);
2342   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2343
2344   // Test renderer removed when visual destroyed
2345   DALI_TEST_CHECK(actor.GetRendererCount() == 2u);
2346   dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL2, false); // TEST_VISUAL2 no longer requires the texture as release policy DETACHED
2347   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
2348   application.SendNotification();
2349   application.Render();
2350
2351   // Test texture was not deleted as TEST_VISUAL release policy is DESTROYED and is still required.
2352   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
2353
2354   dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
2355   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2356   application.SendNotification();
2357   application.Render();
2358
2359   tet_infoline("Ensure a texture is not deleted as second visual used the DESTROYED release policy");
2360   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
2361
2362   END_TEST;
2363 }
2364
2365 int UtcDaliImageVisualReleasePolicy08(void)
2366 {
2367   ToolkitTestApplication application;
2368   tet_infoline("UtcDaliImageVisualReleasePolicy08 Ensure TextureSet is same after detach/attach on stage when texture used the DESTROYED release policy");
2369
2370   tet_infoline("Create first visual with DESTROYED release policy");
2371   Visual::Base imageVisualDestroyed = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DESTROYED);
2372
2373   // Set up trace debug
2374   TestGlAbstraction& gl           = application.GetGlAbstraction();
2375   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2376   textureTrace.Enable(true);
2377
2378   tet_infoline("Register visuals with control and ensure it has the only handles");
2379   DummyControl        actor     = DummyControl::New(true);
2380   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2381   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisualDestroyed);
2382   imageVisualDestroyed.Reset(); // reduce ref count so only the control keeps the visual alive.
2383
2384   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2385
2386   // Test initially zero renderers
2387   application.SendNotification();
2388   application.Render(0);
2389   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2390   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2391   textureTrace.Reset();
2392
2393   application.GetScene().Add(actor);
2394
2395   // Wait for image to load
2396   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2397
2398   application.SendNotification();
2399   application.Render(0);
2400   tet_infoline("Ensure a texture is created");
2401   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2402   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2403   textureTrace.Reset();
2404
2405   // Ensure TextureSet is same after detach/attach on stage when texture used the DESTROYED release policy
2406   // 1. Get TextureSet
2407   TextureSet textureSetBefore = actor.GetRendererAt(0u).GetTextures();
2408
2409   // 2.Remove actor from stage. In this case, renderer also is deleted.
2410   tet_infoline("Remove actor from stage");
2411   application.GetScene().Remove(actor);
2412   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2413   application.SendNotification();
2414   application.Render();
2415
2416   tet_infoline("Ensure a texture is not deleted as visual used the DESTROYED release policy");
2417   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 0, TEST_LOCATION);
2418   textureTrace.Reset();
2419
2420   // 3.Add actor in stage. In this case, renderer is created.
2421   tet_infoline("Add actor in stage");
2422   application.GetScene().Add(actor);
2423   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
2424   application.SendNotification();
2425   application.Render();
2426   tet_infoline("Ensure a texture is not created again");
2427   DALI_TEST_EQUALS(textureTrace.CountMethod("GenTextures"), 0, TEST_LOCATION);
2428   textureTrace.Reset();
2429
2430   // 4.Compare Texture with before and after. textureSet need to be same because release policy is the DESTROYED.
2431   tet_infoline("Ensure a textureSet is not deleted because it is used the DESTROYED release policy");
2432   TextureSet textureSetAfter = actor.GetRendererAt(0u).GetTextures();
2433   DALI_TEST_CHECK(textureSetBefore == textureSetAfter);
2434   textureSetBefore.Reset();
2435   textureSetAfter.Reset();
2436
2437   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL);
2438   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2439   application.SendNotification();
2440   application.Render();
2441   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION);
2442
2443   END_TEST;
2444 }
2445
2446 int UtcDaliImageVisualReleasePolicy09(void)
2447 {
2448   ToolkitTestApplication application;
2449   tet_infoline("UtcDaliImageVisualReleasePolicy09 Destroyed Policy with N-Patch, Texture should be deleted when visual destroyed");
2450
2451   Property::Map propertyMapNPatchReleasePolicy;
2452   propertyMapNPatchReleasePolicy.Insert(Visual::Property::TYPE, Visual::N_PATCH);
2453   propertyMapNPatchReleasePolicy.Insert(ImageVisual::Property::URL, TEST_N_PATCH_IMAGE_FILE_NAME);
2454   propertyMapNPatchReleasePolicy.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, TEST_MASK_IMAGE_FILE_NAME);
2455   propertyMapNPatchReleasePolicy.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
2456   propertyMapNPatchReleasePolicy.Insert(ImageVisual::Property::RELEASE_POLICY, ImageVisual::ReleasePolicy::DESTROYED);
2457
2458   VisualFactory factory     = VisualFactory::Get();
2459   Visual::Base  imageVisual = factory.CreateVisual(propertyMapNPatchReleasePolicy);
2460   DALI_TEST_CHECK(imageVisual);
2461
2462   // Setup debug trace
2463   TestGlAbstraction& gl           = application.GetGlAbstraction();
2464   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2465   textureTrace.Enable(true);
2466
2467   tet_infoline("Register visual with control and ensure it has the only handle");
2468   DummyControl        actor     = DummyControl::New(true);
2469   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2470   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
2471   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2472
2473   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2474
2475   application.SendNotification();
2476   application.Render(0);
2477   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2478   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2479
2480   application.GetScene().Add(actor);
2481
2482   // Wait for image to load
2483   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
2484
2485   application.SendNotification();
2486   application.Render(0);
2487   // Test renderer and texture created
2488   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2489   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2490
2491   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
2492   tet_infoline("Destroy visual by UnRegistering visual with control, check renderer is destroyed");
2493   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL);
2494   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
2495   application.SendNotification();
2496   application.Render();
2497
2498   // Test texture removed after visual destroyed.
2499   tet_infoline("Ensure texture is deleted after visual destroyed");
2500   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 2, TEST_LOCATION);
2501
2502   END_TEST;
2503 }
2504
2505 int UtcDaliImageVisualLoadPolicy01(void)
2506 {
2507   ToolkitTestApplication application;
2508   tet_infoline("UtcDaliImageVisualLoadPolicy01 Load a visual image before attaching to stage");
2509
2510   // Set up trace debug
2511   TestGlAbstraction& gl           = application.GetGlAbstraction();
2512   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2513   textureTrace.Enable(true);
2514
2515   tet_infoline("Create visual with IMMEDIATE load policy");
2516   VisualFactory factory = VisualFactory::Get();
2517
2518   Property::Map propertyMap;
2519   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
2520   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
2521   propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
2522   propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
2523   propertyMap.Insert("loadPolicy", ImageVisual::LoadPolicy::IMMEDIATE);
2524
2525   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
2526
2527   Property::Map resultMap;
2528   imageVisual.CreatePropertyMap(resultMap);
2529   DALI_TEST_CHECK(!resultMap.Empty());
2530   DALI_TEST_EQUALS((resultMap.Find(ImageVisual::Property::LOAD_POLICY))->Get<int>(), (int)ImageVisual::LoadPolicy::IMMEDIATE, TEST_LOCATION);
2531
2532   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2533
2534   // Ensure texture has been uploaded
2535   application.SendNotification();
2536   application.Render();
2537
2538   tet_infoline("Ensure texture loading starts after visual created");
2539   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2540   textureTrace.Reset();
2541
2542   tet_infoline("Register visuals with control and ensure it has the only handles");
2543   DummyControl        actor     = DummyControl::New(true);
2544   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2545   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
2546   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2547
2548   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2549   application.GetScene().Add(actor);
2550   tet_infoline("Ensure nothing triggers another load as texure already loaded");
2551   const unsigned int TIME_OUT_3_SECONDS = 3;
2552   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1, TIME_OUT_3_SECONDS), false, TEST_LOCATION);
2553
2554   application.SendNotification();
2555   application.Render();
2556
2557   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2558   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2559
2560   // Ensure texture is deleted when no longer needed (ref count was correct )
2561   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL);
2562
2563   application.SendNotification();
2564   application.Render();
2565
2566   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
2567   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION);
2568
2569   END_TEST;
2570 }
2571
2572 int UtcDaliImageVisualLoadPolicy02(void)
2573 {
2574   ToolkitTestApplication application;
2575   tet_infoline("UtcDaliImageVisualLoadPolicy01 Load a visual image only after attached to stage");
2576
2577   // Set up trace debug
2578   TestGlAbstraction& gl           = application.GetGlAbstraction();
2579   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2580   textureTrace.Enable(true);
2581
2582   tet_infoline("Create visual with IMMEDIATE load policy");
2583   Visual::Base imageVisual = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::ATTACHED);
2584
2585   const unsigned int TIME_OUT_3_SECONDS = 3;
2586   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1, TIME_OUT_3_SECONDS), false, TEST_LOCATION);
2587
2588   // Act on meeage queue even although nothing expected to load
2589   application.SendNotification();
2590   application.Render();
2591
2592   tet_infoline("Ensure texture is not generated yet");
2593   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), false, TEST_LOCATION);
2594   textureTrace.Reset();
2595
2596   tet_infoline("Register visuals with control and ensure it has the only handles");
2597   DummyControl        actor     = DummyControl::New(true);
2598   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2599   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
2600   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2601
2602   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2603   application.GetScene().Add(actor);
2604   tet_infoline("Allow image time to load");
2605   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2606
2607   application.SendNotification();
2608   application.Render();
2609
2610   tet_infoline("Ensure texture generated and renderer created");
2611   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2612   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2613
2614   // Ensure texture is delete when no longer needed
2615   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL);
2616
2617   application.SendNotification();
2618   application.Render();
2619
2620   DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
2621   DALI_TEST_EQUALS(textureTrace.CountMethod("DeleteTextures"), 1, TEST_LOCATION);
2622
2623   END_TEST;
2624 }
2625
2626 int UtcDaliImageVisualLoadPolicy03(void)
2627 {
2628   ToolkitTestApplication application;
2629   tet_infoline("UtcDaliImageVisualLoadPolicy03 Load a visual image and receive ResourceReady Signal when loaded");
2630
2631   const bool VISUAL_NOT_ENABLED(false); // Instead of just passing 'false' into an API.
2632
2633   // Set up trace debug
2634   TestGlAbstraction& gl           = application.GetGlAbstraction();
2635   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2636   textureTrace.Enable(true);
2637
2638   tet_infoline("Create a control and connect to resource ready signal without adding to stage");
2639   DummyControl actor = DummyControl::New(true);
2640   actor.ResourceReadySignal().Connect(&ResourceReadySignal);
2641   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2642   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2643
2644   tet_infoline("Create visual with IMMEDIATE load policy");
2645   Visual::Base imageVisual = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::IMMEDIATE);
2646
2647   tet_infoline("Registering visual allows control to get a signal once loaded even if visual not enabled( not staged )");
2648   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual, VISUAL_NOT_ENABLED);
2649   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2650
2651   tet_infoline("Allow image time to load resource");
2652   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2653   application.SendNotification();
2654   application.Render();
2655
2656   // Ensure texture has been uploaded
2657   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2658   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
2659
2660   END_TEST;
2661 }
2662
2663 int UtcDaliImageVisualLoadPolicy04(void)
2664 {
2665   ToolkitTestApplication application;
2666   tet_infoline("UtcDaliImageVisualLoadPolicy04 First part  Load a visual image before attaching to stage");
2667   tet_infoline("Second part, Reuse the same image in aonther control and check resource ready signal fired");
2668
2669   const bool VISUAL_NOT_ENABLED(false); // Instead of just passing false into an API.
2670
2671   // Set up trace debug
2672   TestGlAbstraction& gl           = application.GetGlAbstraction();
2673   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2674   textureTrace.Enable(true);
2675
2676   tet_infoline("Create a control and connect to resource ready signal");
2677   DummyControl actor = DummyControl::New(true);
2678   actor.ResourceReadySignal().Connect(&ResourceReadySignal);
2679   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2680   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2681
2682   tet_infoline("Create visual with IMMEDIATE load policy");
2683   Visual::Base imageVisual = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::IMMEDIATE);
2684
2685   tet_infoline("Registering visual allows control to get a signal once loaded even if visual not enabled( staged )");
2686   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual, VISUAL_NOT_ENABLED);
2687   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2688
2689   tet_infoline("Allow image time to load");
2690   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2691   application.SendNotification();
2692   application.Render();
2693
2694   tet_infoline("Testing texture is loaded and resource ready signal fired");
2695   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2696   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
2697
2698   tet_infoline("Original control correctly signalled, now testing for signal with new Control reusing the image");
2699
2700   gResourceReadySignalFired        = false; // Reset signal check ready for testing next Control
2701   Visual::Base        imageVisual2 = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::IMMEDIATE);
2702   DummyControl        actor2       = DummyControl::New(true);
2703   Impl::DummyControl& dummyImpl2   = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2704   actor2.ResourceReadySignal().Connect(&ResourceReadySignal);
2705
2706   tet_infoline("Registering visual this should trigger the loading signal as is already image loaded for previous control");
2707   dummyImpl2.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual2);
2708   imageVisual2.Reset(); // reduce ref count so only the control keeps the visual alive.
2709   actor2.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2710   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(0), true, TEST_LOCATION); // Not expecting any further loading as texture is being reused.
2711   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
2712
2713   END_TEST;
2714 }
2715
2716 int UtcDaliImageVisualLoadPolicy05(void)
2717 {
2718   ToolkitTestApplication application;
2719   tet_infoline("UtcDaliImageVisualLoadPolicy05 LoadPolicy::ATTACHED (default) First part  Load a visual image before attaching to stage");
2720   tet_infoline("Second part, Reuse the same image in aonther control and check resource ready signal fired");
2721   // Set up trace debug
2722   TestGlAbstraction& gl           = application.GetGlAbstraction();
2723   TraceCallStack&    textureTrace = gl.GetTextureTrace();
2724   textureTrace.Enable(true);
2725
2726   tet_infoline("Create a control and connect to resource ready signal");
2727   DummyControl actor = DummyControl::New(true);
2728   actor.ResourceReadySignal().Connect(&ResourceReadySignal);
2729   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2730   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2731   application.GetScene().Add(actor);
2732
2733   tet_infoline("Create visual with ATTACHED load policy");
2734   Visual::Base imageVisual = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::ATTACHED);
2735
2736   tet_infoline("Registering visual allows control to get a signal once loaded");
2737   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
2738   imageVisual.Reset(); // reduce ref count so only the control keeps the visual alive.
2739
2740   tet_infoline("Allow image time to load");
2741   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2742   application.SendNotification();
2743   application.Render();
2744
2745   tet_infoline("Testing texture is loaded and resource ready signal fired");
2746   DALI_TEST_EQUALS(textureTrace.FindMethod("GenTextures"), true, TEST_LOCATION);
2747   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
2748
2749   tet_infoline("Original control correctly signalled, now testing for signal with new Control reusing the image");
2750
2751   gResourceReadySignalFired        = false; // Reset signal check ready for testing next Control
2752   Visual::Base        imageVisual2 = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::ATTACHED);
2753   DummyControl        actor2       = DummyControl::New(true);
2754   Impl::DummyControl& dummyImpl2   = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2755   actor2.ResourceReadySignal().Connect(&ResourceReadySignal);
2756
2757   tet_infoline("Registering visual this should trigger the loading signal as is already image loaded for previous control");
2758   dummyImpl2.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual2);
2759   imageVisual2.Reset(); // reduce ref count so only the control keeps the visual alive.
2760   actor2.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2761   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(0), true, TEST_LOCATION); // Not expecting any further loading as texture is being reused.
2762   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
2763
2764   END_TEST;
2765 }
2766
2767 int UtcDaliImageVisualOrientationCorrection(void)
2768 {
2769   ToolkitTestApplication application;
2770   tet_infoline("UtcDaliImageVisualOrientationCorrection Enabling OrientationCorrection should rotate an image with exif (90deg) orientation data with requested");
2771
2772   VisualFactory factory = VisualFactory::Get();
2773   tet_infoline("Create visual with Orientation correction set OFF");
2774   Property::Map propertyMap;
2775   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
2776   propertyMap.Insert(ImageVisual::Property::URL, TEST_ROTATED_IMAGE);
2777   propertyMap.Insert("orientationCorrection", false);
2778   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
2779
2780   tet_infoline("Create control for visual, need to loaded it");
2781   DummyControl        actor     = DummyControl::New(true);
2782   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2783   application.GetScene().Add(actor);
2784
2785   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
2786   // Wait for image to load
2787   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2788
2789   Vector2 originalImageSize;
2790   tet_infoline("Get size of original visual to compare later with rotated image");
2791   imageVisual.GetNaturalSize(originalImageSize);
2792   DALI_TEST_GREATER(originalImageSize.width, originalImageSize.height, TEST_LOCATION); // Width and Height must be different for this test.
2793   imageVisual.Reset();                                                                 // remove handle so can unregister it and remove from cache
2794   dummyImpl.UnregisterVisual(DummyControl::Property::TEST_VISUAL);
2795   application.SendNotification();
2796   application.Render();
2797
2798   tet_infoline("Create visual with Orientation correction set ON ");
2799   propertyMap.Clear();
2800   propertyMap.Insert(Visual::Property::TYPE, Visual::IMAGE);
2801   propertyMap.Insert(ImageVisual::Property::URL, TEST_ROTATED_IMAGE);
2802   propertyMap.Insert(ImageVisual::Property::ORIENTATION_CORRECTION, true);
2803   imageVisual = factory.CreateVisual(propertyMap);
2804
2805   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual);
2806   // Wait for image to load
2807   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2808
2809   Vector2 rotatedImageSize;
2810   imageVisual.GetNaturalSize(rotatedImageSize);
2811   tet_infoline("Confirm that visual has rotated");
2812   DALI_TEST_EQUALS(originalImageSize.width, rotatedImageSize.height, TEST_LOCATION);
2813   DALI_TEST_EQUALS(originalImageSize.height, rotatedImageSize.width, TEST_LOCATION);
2814
2815   Property::Map resultMap;
2816   imageVisual.CreatePropertyMap(resultMap);
2817
2818   // check the Property::ORIENTATION_CORRECTION value from the returned map
2819   Property::Value* typeValue = resultMap.Find(ImageVisual::Property::ORIENTATION_CORRECTION, Property::BOOLEAN);
2820   DALI_TEST_EQUALS(typeValue->Get<bool>(), true, TEST_LOCATION);
2821
2822   END_TEST;
2823 }
2824
2825 int UtcDaliImageVisualCustomShader(void)
2826 {
2827   ToolkitTestApplication application;
2828   tet_infoline("UtcDaliImageVisualCustomShader Test custom shader");
2829
2830   VisualFactory     factory = VisualFactory::Get();
2831   Property::Map     properties;
2832   Property::Map     shader;
2833   const std::string vertexShader                    = "Foobar";
2834   const std::string fragmentShader                  = "Foobar";
2835   shader[Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
2836   shader[Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
2837
2838   properties[Visual::Property::TYPE]     = Visual::IMAGE;
2839   properties[Visual::Property::SHADER]   = shader;
2840   properties[ImageVisual::Property::URL] = TEST_IMAGE_FILE_NAME;
2841
2842   Visual::Base visual = factory.CreateVisual(properties);
2843
2844   // trigger creation through setting on stage
2845   DummyControl        dummy     = DummyControl::New(true);
2846   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
2847   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2848
2849   dummy.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2850   dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2851   application.GetScene().Add(dummy);
2852
2853   application.SendNotification();
2854   application.Render();
2855
2856   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2857
2858   Renderer        renderer = dummy.GetRendererAt(0);
2859   Shader          shader2  = renderer.GetShader();
2860   Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
2861   Property::Map*  map      = value.GetMap();
2862   DALI_TEST_CHECK(map);
2863
2864   Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
2865   DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
2866
2867   Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
2868   DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
2869
2870   shader.Clear();
2871
2872   shader[Visual::Shader::Property::HINTS] = Shader::Hint::OUTPUT_IS_TRANSPARENT;
2873   properties[Visual::Property::SHADER]    = shader;
2874
2875   Visual::Base visual1 = factory.CreateVisual(properties);
2876
2877   // trigger creation through setting on stage
2878   DummyControl        dummy1     = DummyControl::New(true);
2879   Impl::DummyControl& dummyImpl1 = static_cast<Impl::DummyControl&>(dummy1.GetImplementation());
2880   dummyImpl1.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual1);
2881   dummy1.SetProperty(Actor::Property::SIZE, Vector2(200, 200));
2882   dummy1.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2883   application.GetScene().Add(dummy1);
2884
2885   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2886   glAbstraction.EnableEnableDisableCallTrace(true);
2887
2888   application.SendNotification();
2889   application.Render();
2890
2891   TraceCallStack&    glEnableStack = glAbstraction.GetEnableDisableTrace();
2892   std::ostringstream blendStr;
2893   blendStr << std::hex << GL_BLEND;
2894   DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2895
2896   END_TEST;
2897 }
2898
2899 void ResourceReadyLoadNext(Control control)
2900 {
2901   static int callNumber = 0;
2902
2903   gResourceReadySignalFired = true;
2904   gReadyIds.push_back(control.GetProperty<int>(Actor::Property::ID));
2905
2906   if(callNumber == 0)
2907   {
2908     DALI_TEST_EQUALS(control.GetVisualResourceStatus(DummyControl::Property::TEST_VISUAL), Toolkit::Visual::ResourceStatus::FAILED, TEST_LOCATION);
2909
2910     tet_infoline("Create visual with loaded image from within the signal handler");
2911     VisualFactory factory     = VisualFactory::Get();
2912     Visual::Base  imageVisual = factory.CreateVisual(TEST_IMAGE_FILE_NAME, ImageDimensions{20, 30});
2913
2914     Impl::DummyControl& controlImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
2915     controlImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual); // This should trigger another signal.
2916     callNumber = 1;
2917   }
2918   else
2919   {
2920     tet_infoline("3rd signal called");
2921     DALI_TEST_CHECK(true);
2922   }
2923 }
2924
2925 int UtcDaliImageVisualLoadReady01(void)
2926 {
2927   ToolkitTestApplication application;
2928   tet_infoline("UtcDaliImageVisualLoadReady01");
2929   tet_infoline("First part:  Load an image visual for one resource, then another image visual for a second resource.");
2930   tet_infoline("Second part, In the ready signal for the second image visual, add a 3rd visual with the first URL");
2931   tet_infoline("Should get a ready signal for all three visuals");
2932
2933   ClearReadyIds();
2934
2935   tet_infoline("Create a control and connect to resource ready signal");
2936   DummyControl actor    = DummyControl::New(true);
2937   int          actor1Id = actor.GetProperty<int>(Actor::Property::ID);
2938   actor.ResourceReadySignal().Connect(&ResourceReadySignal);
2939   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2940   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2941   application.GetScene().Add(actor);
2942
2943   tet_infoline("Create visual with IMMEDIATE load policy");
2944   Visual::Base imageVisual1 = CreateVisualWithPolicy(TEST_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::IMMEDIATE);
2945
2946   tet_infoline("Registering visual allows control to get a signal once loaded even if visual not enabled( staged )");
2947   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual1);
2948
2949   tet_infoline("Allow image time to load");
2950   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2951   application.SendNotification();
2952   application.Render();
2953
2954   tet_infoline("Testing texture is loaded and resource ready signal fired");
2955   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
2956   DALI_TEST_EQUALS(gReadyIds[0], actor1Id, TEST_LOCATION);
2957
2958   tet_infoline("Original control correctly signalled, now testing failing image");
2959
2960   gResourceReadySignalFired = false; // Reset signal check ready for testing next Control
2961   ClearReadyIds();
2962
2963   Visual::Base imageVisual2 = CreateVisualWithPolicy(TEST_BROKEN_IMAGE_FILE_NAME, ImageVisual::Property::LOAD_POLICY, ImageVisual::LoadPolicy::IMMEDIATE);
2964
2965   DummyControl        actor2     = DummyControl::New(true);
2966   int                 actor2Id   = actor2.GetProperty<int>(Actor::Property::ID);
2967   Impl::DummyControl& dummyImpl2 = static_cast<Impl::DummyControl&>(actor2.GetImplementation());
2968   actor2.ResourceReadySignal().Connect(&ResourceReadyLoadNext);
2969
2970   tet_infoline("Registering visual this should trigger the ready signal when the image fails to load");
2971   dummyImpl2.RegisterVisual(DummyControl::Property::TEST_VISUAL, imageVisual2);
2972
2973   actor2.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
2974   application.GetScene().Add(actor2);
2975
2976   tet_infoline("Wait for loading thread to finish");
2977   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
2978   DALI_TEST_EQUALS(gResourceReadySignalFired, true, TEST_LOCATION);
2979
2980   DALI_TEST_EQUALS(gReadyIds[0], actor2Id, TEST_LOCATION);
2981
2982   tet_infoline("Check for 3rd signal");
2983   application.SendNotification();
2984   DALI_TEST_EQUALS(gReadyIds.size(), 2, TEST_LOCATION);
2985   DALI_TEST_EQUALS(gReadyIds[1], actor2Id, TEST_LOCATION);
2986
2987   END_TEST;
2988 }
2989
2990 int UtcDaliImageVisualLoadImagePlanes01(void)
2991 {
2992   EnvironmentVariable::SetTestEnvironmentVariable(LOAD_IMAGE_YUV_PLANES_ENV, "1");
2993   EnvironmentVariable::SetTestEnvironmentVariable(ENABLE_DECODE_JPEG_TO_YUV_420_ENV, "1");
2994
2995   ToolkitTestApplication application;
2996
2997   VisualFactory factory = VisualFactory::Get();
2998   DALI_TEST_CHECK(factory);
2999
3000   Property::Map propertyMap;
3001   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
3002   propertyMap.Insert(ImageVisual::Property::URL, TEST_YUV420_IMAGE_FILE_NAME);
3003
3004   Visual::Base visual = factory.CreateVisual(propertyMap);
3005   DALI_TEST_CHECK(visual);
3006
3007   DummyControl      actor     = DummyControl::New();
3008   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
3009   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
3010   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3011   application.GetScene().Add(actor);
3012
3013   application.SendNotification();
3014   application.Render();
3015
3016   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
3017
3018   TestGlAbstraction& gl           = application.GetGlAbstraction();
3019   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3020   textureTrace.Enable(true);
3021
3022   application.SendNotification();
3023   application.Render();
3024
3025   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
3026   DALI_TEST_EQUALS(actor.IsResourceReady(), true, TEST_LOCATION);
3027   DALI_TEST_EQUALS(textureTrace.CountMethod("GenTextures"), 3, TEST_LOCATION);
3028
3029   Renderer renderer           = actor.GetRendererAt(0);
3030   auto     preMultipliedAlpha = renderer.GetProperty<bool>(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
3031   DALI_TEST_EQUALS(preMultipliedAlpha, false, TEST_LOCATION);
3032
3033   END_TEST;
3034 }
3035
3036 int UtcDaliImageVisualLoadImagePlanes02(void)
3037 {
3038   EnvironmentVariable::SetTestEnvironmentVariable(LOAD_IMAGE_YUV_PLANES_ENV, "1");
3039   EnvironmentVariable::SetTestEnvironmentVariable(ENABLE_DECODE_JPEG_TO_YUV_420_ENV, "1");
3040
3041   ToolkitTestApplication application;
3042
3043   VisualFactory factory = VisualFactory::Get();
3044   DALI_TEST_CHECK(factory);
3045
3046   // Alpha masking case - not support yuv planes
3047   Property::Map propertyMap;
3048   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
3049   propertyMap.Insert(ImageVisual::Property::URL, TEST_YUV420_IMAGE_FILE_NAME);
3050   propertyMap.Insert(ImageVisual::Property::ALPHA_MASK_URL, TEST_MASK_IMAGE_FILE_NAME);
3051
3052   Visual::Base visual = factory.CreateVisual(propertyMap);
3053   DALI_TEST_CHECK(visual);
3054
3055   DummyControl      actor     = DummyControl::New();
3056   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
3057   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
3058   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3059   application.GetScene().Add(actor);
3060
3061   application.SendNotification();
3062   application.Render();
3063
3064   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(3), true, TEST_LOCATION);
3065
3066   TestGlAbstraction& gl           = application.GetGlAbstraction();
3067   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3068   textureTrace.Enable(true);
3069
3070   application.SendNotification();
3071   application.Render();
3072
3073   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
3074   DALI_TEST_EQUALS(actor.IsResourceReady(), true, TEST_LOCATION);
3075   DALI_TEST_EQUALS(textureTrace.CountMethod("GenTextures"), 1, TEST_LOCATION);
3076
3077   END_TEST;
3078 }
3079
3080 int UtcDaliImageVisualLoadImagePlanes03(void)
3081 {
3082   EnvironmentVariable::SetTestEnvironmentVariable(LOAD_IMAGE_YUV_PLANES_ENV, "1");
3083   EnvironmentVariable::SetTestEnvironmentVariable(ENABLE_DECODE_JPEG_TO_YUV_420_ENV, "1");
3084
3085   ToolkitTestApplication application;
3086
3087   VisualFactory factory = VisualFactory::Get();
3088   DALI_TEST_CHECK(factory);
3089
3090   TestGlAbstraction& gl           = application.GetGlAbstraction();
3091   TraceCallStack&    textureTrace = gl.GetTextureTrace();
3092   textureTrace.Enable(true);
3093
3094   Property::Map propertyMap;
3095   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
3096   propertyMap.Insert(ImageVisual::Property::URL, TEST_YUV420_IMAGE_FILE_NAME);
3097   propertyMap.Insert(ImageVisual::Property::SYNCHRONOUS_LOADING, true);
3098
3099   Visual::Base visual = factory.CreateVisual(propertyMap);
3100   DALI_TEST_CHECK(visual);
3101
3102   DummyControl      actor     = DummyControl::New();
3103   DummyControlImpl& dummyImpl = static_cast<DummyControlImpl&>(actor.GetImplementation());
3104   dummyImpl.RegisterVisual(Control::CONTROL_PROPERTY_END_INDEX + 1, visual);
3105   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3106   application.GetScene().Add(actor);
3107
3108   application.SendNotification();
3109   application.Render();
3110
3111   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
3112   DALI_TEST_EQUALS(actor.IsResourceReady(), true, TEST_LOCATION);
3113   DALI_TEST_EQUALS(textureTrace.CountMethod("GenTextures"), 3, TEST_LOCATION);
3114