175e834ba381eded61bd21e47c8597d1e75b5a3d
[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-toolkit / utc-Dali-Visual.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 <unistd.h>
19 #include <iostream>
20
21 #include <dali-toolkit-test-suite-utils.h>
22 #include <dali-toolkit/dali-toolkit.h>
23 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
24 #include <dali-toolkit/devel-api/controls/control-devel.h>
25 #include <dali-toolkit/devel-api/text/rendering-backend.h>
26 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
27 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
28 #include <dali-toolkit/devel-api/visuals/animated-gradient-visual-properties-devel.h>
29 #include <dali-toolkit/devel-api/visuals/color-visual-properties-devel.h>
30 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
31 #include <dali-toolkit/devel-api/visuals/text-visual-properties-devel.h>
32 #include <dali-toolkit/devel-api/visuals/visual-actions-devel.h>
33 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
34 #include <dali/devel-api/actors/actor-devel.h>
35 #include <dali/devel-api/object/handle-devel.h>
36 #include <dali/devel-api/text-abstraction/font-client.h>
37 #include <toolkit-event-thread-callback.h>
38
39 #include "dummy-control.h"
40
41 using namespace Dali;
42 using namespace Dali::Toolkit;
43
44 namespace
45 {
46 const char* TEST_GIF_FILE_NAME          = TEST_RESOURCE_DIR "/anim.gif";
47 const char* TEST_IMAGE_FILE_NAME        = TEST_RESOURCE_DIR "/gallery-small-1.jpg";
48 const char* TEST_NPATCH_FILE_NAME       = TEST_RESOURCE_DIR "/button-up.9.png";
49 const char* TEST_SVG_FILE_NAME          = TEST_RESOURCE_DIR "/svg1.svg";
50 const char* TEST_OBJ_FILE_NAME          = TEST_RESOURCE_DIR "/Cube.obj";
51 const char* TEST_MTL_FILE_NAME          = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
52 const char* TEST_VECTOR_IMAGE_FILE_NAME = TEST_RESOURCE_DIR "/insta_camera.json";
53 const char* TEST_RESOURCE_LOCATION      = TEST_RESOURCE_DIR "/";
54
55 const std::string DEFAULT_FONT_DIR("/resources/fonts");
56
57 Property::Map DefaultTransform()
58 {
59   Property::Map transformMap;
60   transformMap
61     .Add(Toolkit::Visual::Transform::Property::OFFSET, Vector2(0.0f, 0.0f))
62     .Add(Toolkit::Visual::Transform::Property::SIZE, Vector2(1.0f, 1.0f))
63     .Add(Toolkit::Visual::Transform::Property::ORIGIN, Toolkit::Align::TOP_BEGIN)
64     .Add(Toolkit::Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::TOP_BEGIN)
65     .Add(Toolkit::Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE))
66     .Add(Toolkit::Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
67   return transformMap;
68 }
69
70 bool DaliTestCheckMaps(const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet)
71 {
72   if(fontStyleMapGet.Count() == fontStyleMapSet.Count())
73   {
74     for(unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index)
75     {
76       const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue(index);
77
78       Property::Value* valueSet = NULL;
79       if(valueGet.first.type == Property::Key::INDEX)
80       {
81         valueSet = fontStyleMapSet.Find(valueGet.first.indexKey);
82       }
83       else
84       {
85         // Get Key is a string so searching Set Map for a string key
86         valueSet = fontStyleMapSet.Find(valueGet.first.stringKey);
87       }
88
89       if(NULL != valueSet)
90       {
91         if(valueSet->GetType() == Dali::Property::STRING && (valueGet.second.Get<std::string>() != valueSet->Get<std::string>()))
92         {
93           tet_printf("Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str());
94           return false;
95         }
96         else if(valueSet->GetType() == Dali::Property::BOOLEAN && (valueGet.second.Get<bool>() != valueSet->Get<bool>()))
97         {
98           tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<bool>(), valueSet->Get<bool>());
99           return false;
100         }
101         else if(valueSet->GetType() == Dali::Property::INTEGER && (valueGet.second.Get<int>() != valueSet->Get<int>()))
102         {
103           tet_printf("Value got : [%d], expected : [%d]", valueGet.second.Get<int>(), valueSet->Get<int>());
104           return false;
105         }
106         else if(valueSet->GetType() == Dali::Property::FLOAT && (valueGet.second.Get<float>() != valueSet->Get<float>()))
107         {
108           tet_printf("Value got : [%f], expected : [%f]", valueGet.second.Get<float>(), valueSet->Get<float>());
109           return false;
110         }
111         else if(valueSet->GetType() == Dali::Property::VECTOR2 && (valueGet.second.Get<Vector2>() != valueSet->Get<Vector2>()))
112         {
113           Vector2 vector2Get = valueGet.second.Get<Vector2>();
114           Vector2 vector2Set = valueSet->Get<Vector2>();
115           tet_printf("Value got : [%f, %f], expected : [%f, %f]", vector2Get.x, vector2Get.y, vector2Set.x, vector2Set.y);
116           return false;
117         }
118         else if(valueSet->GetType() == Dali::Property::VECTOR4 && (valueGet.second.Get<Vector4>() != valueSet->Get<Vector4>()))
119         {
120           Vector4 vector4Get = valueGet.second.Get<Vector4>();
121           Vector4 vector4Set = valueSet->Get<Vector4>();
122           tet_printf("Value got : [%f, %f, %f, %f], expected : [%f, %f, %f, %f]", vector4Get.r, vector4Get.g, vector4Get.b, vector4Get.a, vector4Set.r, vector4Set.g, vector4Set.b, vector4Set.a);
123           return false;
124         }
125       }
126       else
127       {
128         if(valueGet.first.type == Property::Key::INDEX)
129         {
130           tet_printf("  The key %d doesn't exist.", valueGet.first.indexKey);
131         }
132         else
133         {
134           tet_printf("  The key %s doesn't exist.", valueGet.first.stringKey.c_str());
135         }
136         return false;
137       }
138     }
139   }
140
141   return true;
142 }
143
144 } //namespace
145
146 void dali_visual_startup(void)
147 {
148   test_return_value = TET_UNDEF;
149 }
150
151 void dali_visual_cleanup(void)
152 {
153   test_return_value = TET_PASS;
154 }
155
156 static void TestMixColor(Visual::Base visual, Property::Index mixColorIndex, const Vector4& testColor)
157 {
158   Property::Map map;
159   visual.CreatePropertyMap(map);
160   Property::Value* value = map.Find(mixColorIndex);
161   DALI_TEST_CHECK(value);
162   Vector3 mixColor1;
163   DALI_TEST_CHECK(value->Get(mixColor1));
164   DALI_TEST_EQUALS(mixColor1, Vector3(testColor), 0.001, TEST_LOCATION);
165
166   value = map.Find(Visual::Property::MIX_COLOR);
167   DALI_TEST_CHECK(value);
168   Vector4 mixColor2;
169   DALI_TEST_CHECK(value->Get(mixColor2));
170   DALI_TEST_EQUALS(mixColor2, testColor, 0.001, TEST_LOCATION);
171
172   value = map.Find(Visual::Property::OPACITY);
173   DALI_TEST_CHECK(value);
174   float opacity;
175   DALI_TEST_CHECK(value->Get(opacity));
176   DALI_TEST_EQUALS(opacity, testColor.a, 0.001, TEST_LOCATION);
177 }
178
179 int UtcDaliVisualCopyAndAssignment(void)
180 {
181   ToolkitTestApplication application;
182   tet_infoline("UtcDaliVisualCopyAndAssignment");
183
184   VisualFactory factory = VisualFactory::Get();
185   Property::Map propertyMap;
186   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
187   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
188   Visual::Base visual = factory.CreateVisual(propertyMap);
189
190   Visual::Base visualCopy(visual);
191   DALI_TEST_CHECK(visual == visualCopy);
192
193   Visual::Base emptyVisual;
194   Visual::Base emptyVisualCopy(emptyVisual);
195   DALI_TEST_CHECK(emptyVisual == emptyVisualCopy);
196
197   Visual::Base visualEquals;
198   visualEquals = visual;
199   DALI_TEST_CHECK(visual == visualEquals);
200
201   Visual::Base emptyVisualEquals;
202   emptyVisualEquals = emptyVisual;
203   DALI_TEST_CHECK(emptyVisual == emptyVisualEquals);
204
205   //self assignment
206   visual = visual;
207   DALI_TEST_CHECK(visual = visualCopy);
208
209   END_TEST;
210 }
211
212 int UtcDaliVisualSetName01(void)
213 {
214   ToolkitTestApplication application;
215   tet_infoline("UtcDaliVisualSetName");
216
217   VisualFactory factory = VisualFactory::Get();
218   Property::Map propertyMap;
219   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
220   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
221   Visual::Base visual = factory.CreateVisual(propertyMap);
222
223   const char* visualName = "backgroundVisual";
224   visual.SetName(visualName);
225
226   DALI_TEST_EQUALS(visual.GetName(), visualName, TEST_LOCATION);
227
228   END_TEST;
229 }
230
231 int UtcDaliVisualSetGetDepthIndex(void)
232 {
233   ToolkitTestApplication application;
234   tet_infoline("UtcDaliVisualSetDepthIndex");
235
236   VisualFactory factory = VisualFactory::Get();
237   Property::Map propertyMap;
238   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
239   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
240   Visual::Base visual = factory.CreateVisual(propertyMap);
241
242   visual.SetDepthIndex(1);
243
244   DummyControl        dummyControl = DummyControl::New(true);
245   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
246   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
247
248   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
249   application.GetScene().Add(dummyControl);
250
251   int depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
252   DALI_TEST_EQUALS(depthIndex, 1, TEST_LOCATION);
253   DALI_TEST_EQUALS(visual.GetDepthIndex(), 1, TEST_LOCATION);
254
255   visual.SetDepthIndex(-1);
256   depthIndex = dummyControl.GetRendererAt(0u).GetProperty<int>(Renderer::Property::DEPTH_INDEX);
257   DALI_TEST_EQUALS(depthIndex, -1, TEST_LOCATION);
258   DALI_TEST_EQUALS(visual.GetDepthIndex(), -1, TEST_LOCATION);
259
260   END_TEST;
261 }
262
263 int UtcDaliVisualSize(void)
264 {
265   ToolkitTestApplication application;
266   tet_infoline("UtcDaliVisualSize");
267
268   VisualFactory factory = VisualFactory::Get();
269   Vector2       controlSize(20.f, 30.f);
270   Vector2       naturalSize;
271
272   // color colorVisual
273   Dali::Property::Map map;
274   map[Toolkit::Visual::Property::TYPE]  = Visual::COLOR;
275   map[ColorVisual::Property::MIX_COLOR] = Color::MAGENTA;
276
277   Visual::Base colorVisual = factory.CreateVisual(map);
278   colorVisual.SetTransformAndSize(DefaultTransform(), controlSize);
279
280   colorVisual.GetNaturalSize(naturalSize);
281   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
282
283   // image visual
284   map.Clear();
285   map[Toolkit::Visual::Property::TYPE]                = Toolkit::Visual::IMAGE;
286   map[Toolkit::ImageVisual::Property::URL]            = TEST_IMAGE_FILE_NAME;
287   map[Toolkit::ImageVisual::Property::DESIRED_WIDTH]  = 100.0f;
288   map[Toolkit::ImageVisual::Property::DESIRED_HEIGHT] = 200.0f;
289   Visual::Base imageVisual                            = factory.CreateVisual(map);
290   imageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
291
292   imageVisual.GetNaturalSize(naturalSize);
293   DALI_TEST_EQUALS(naturalSize, Vector2(100.f, 200.f), TEST_LOCATION);
294
295   // n patch visual is tested in the utc-Dali-VisualFactory.cpp
296
297   // border visual
298   float borderSize = 5.f;
299   map.Clear();
300   map[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
301   map[BorderVisual::Property::COLOR]   = Color::RED;
302   map[BorderVisual::Property::SIZE]    = borderSize;
303   Visual::Base borderVisual            = factory.CreateVisual(map);
304   borderVisual.SetTransformAndSize(DefaultTransform(), controlSize);
305   borderVisual.GetNaturalSize(naturalSize);
306   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
307
308   // gradient gradientVisual
309   Property::Map propertyMap;
310   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
311   Vector2 start(-1.f, -1.f);
312   Vector2 end(1.f, 1.f);
313   propertyMap.Insert("mixColor", Color::MAGENTA);
314   propertyMap.Insert(GradientVisual::Property::START_POSITION, start);
315   propertyMap.Insert(GradientVisual::Property::END_POSITION, end);
316   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.f, 1.f));
317   propertyMap.Insert(GradientVisual::Property::SPREAD_METHOD, GradientVisual::SpreadMethod::REPEAT);
318   Property::Array stopColors;
319   stopColors.PushBack(Color::RED);
320   stopColors.PushBack(Color::GREEN);
321   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
322   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
323   gradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
324   gradientVisual.GetNaturalSize(naturalSize);
325   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
326
327   // animated gradient visual
328   propertyMap.Clear();
329   propertyMap.Insert(Toolkit::Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
330   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
331   animatedGradientVisual.GetNaturalSize(naturalSize);
332   animatedGradientVisual.SetTransformAndSize(DefaultTransform(), controlSize);
333   DALI_TEST_EQUALS(naturalSize, Vector2::ZERO, TEST_LOCATION);
334
335   // Text visual.
336
337   // Load some fonts to get the same metrics on different platforms.
338   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
339   fontClient.SetDpi(96u, 96u);
340
341   char*             pathNamePtr = get_current_dir_name();
342   const std::string pathName(pathNamePtr);
343   free(pathNamePtr);
344
345   fontClient.GetFontId(pathName + DEFAULT_FONT_DIR + "/tizen/TizenSansRegular.ttf");
346
347   // Create a TextVisual with a font size of 12 first
348   propertyMap.Clear();
349   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
350   propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
351   propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
352   propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
353
354   Visual::Base smallTextVisual = factory.CreateVisual(propertyMap);
355   Vector2      smallTextVisualNaturalSize;
356   smallTextVisual.GetNaturalSize(smallTextVisualNaturalSize);
357
358   // Then create a TextVisual with a font size of 20
359   propertyMap[TextVisual::Property::TEXT] = "<font family='TizenSans' size='20'>Hello world</font>";
360   Visual::Base largeTextVisual            = factory.CreateVisual(propertyMap);
361   Vector2      largeTextVisualNaturalSize;
362   largeTextVisual.GetNaturalSize(largeTextVisualNaturalSize);
363
364   // Compare the sizes of the two text visuals, the second one should be bigger as it has a larger point size in the markup.
365   DALI_TEST_CHECK(smallTextVisualNaturalSize.width < largeTextVisualNaturalSize.width &&
366                   smallTextVisualNaturalSize.height < largeTextVisualNaturalSize.height);
367
368   // The height returned for a particular width should also be greater for the large text visual
369   DALI_TEST_CHECK(smallTextVisual.GetHeightForWidth(40.f) < largeTextVisual.GetHeightForWidth(40.f));
370
371   //AnimatedImageVisual
372   Visual::Base animatedImageVisual = factory.CreateVisual(TEST_GIF_FILE_NAME, ImageDimensions());
373   animatedImageVisual.SetTransformAndSize(DefaultTransform(), controlSize);
374   animatedImageVisual.GetNaturalSize(naturalSize);
375   // TEST_GIF_FILE: anim.gif
376   // resolution: 50*50, frame count: 4, frame delay: 0.2 second for each frame
377   DALI_TEST_EQUALS(naturalSize, Vector2(50.f, 50.f), TEST_LOCATION);
378
379   END_TEST;
380 }
381
382 int UtcDaliVisualSetOnOffScene(void)
383 {
384   ToolkitTestApplication application;
385   tet_infoline("UtcDaliVisualSetOnOffScene");
386
387   VisualFactory factory = VisualFactory::Get();
388   Property::Map propertyMap;
389   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
390   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
391   Visual::Base visual = factory.CreateVisual(propertyMap);
392
393   DummyControl        actor     = DummyControl::New(true);
394   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
395   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
396
397   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
398
399   application.SendNotification();
400   application.Render(0);
401   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
402
403   application.GetScene().Add(actor);
404
405   application.SendNotification();
406   application.Render(0);
407   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
408
409   application.GetScene().Remove(actor);
410
411   application.SendNotification();
412   application.Render(0);
413   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
414
415   END_TEST;
416 }
417
418 int UtcDaliVisualSetOnOffScene2(void)
419 {
420   ToolkitTestApplication application;
421   tet_infoline("UtcDaliVisualSetOnOffScene2");
422
423   VisualFactory factory = VisualFactory::Get();
424   Property::Map propertyMap;
425   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
426   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
427   Visual::Base visual = factory.CreateVisual(propertyMap);
428
429   DummyControl        actor     = DummyControl::New(true);
430   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
431   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
432
433   actor.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
434
435   application.SendNotification();
436   application.Render(0);
437   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
438
439   // First on/off
440   application.GetScene().Add(actor);
441
442   application.SendNotification();
443   application.Render(0);
444
445   // Wait for loading & rasterization
446   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(2), true, TEST_LOCATION);
447
448   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
449   Renderer renderer = actor.GetRendererAt(0);
450   auto     textures = renderer.GetTextures();
451   DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
452
453   application.GetScene().Remove(actor);
454
455   application.SendNotification();
456   application.Render(0);
457   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
458
459   // Second on/off
460   application.GetScene().Add(actor);
461
462   application.SendNotification();
463   application.Render(0);
464   DALI_TEST_EQUALS(Test::WaitForEventThreadTrigger(1), true, TEST_LOCATION);
465   DALI_TEST_CHECK(actor.GetRendererCount() == 1u);
466   renderer = actor.GetRendererAt(0);
467   textures = renderer.GetTextures();
468   DALI_TEST_CHECK(textures.GetTextureCount() != 0u);
469
470   application.GetScene().Remove(actor);
471
472   application.SendNotification();
473   application.Render(0);
474   DALI_TEST_CHECK(actor.GetRendererCount() == 0u);
475
476   END_TEST;
477 }
478
479 int UtcDaliVisualGetPropertyMap1(void)
480 {
481   ToolkitTestApplication application;
482   tet_infoline("UtcDaliVisualGetPropertyMap1: ColorVisual (With base MixColor");
483
484   VisualFactory factory = VisualFactory::Get();
485   Property::Map propertyMap;
486   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
487   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
488   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, 10.0f);
489   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS_POLICY, Toolkit::Visual::Transform::Policy::RELATIVE);
490   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, 20.0f);
491   propertyMap.Insert(DevelVisual::Property::BORDERLINE_COLOR, Color::RED);
492   propertyMap.Insert(DevelVisual::Property::BORDERLINE_OFFSET, -1.0f);
493   propertyMap.Insert(DevelColorVisual::Property::BLUR_RADIUS, 20.0f);
494   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
495
496   Property::Map resultMap;
497   colorVisual.CreatePropertyMap(resultMap);
498
499   Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
500   DALI_TEST_CHECK(typeValue);
501   DALI_TEST_CHECK(typeValue->Get<int>() == Visual::COLOR);
502
503   Property::Value* colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
504   DALI_TEST_CHECK(colorValue);
505   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
506
507   Property::Value* cornerRadiusValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
508   DALI_TEST_CHECK(cornerRadiusValue);
509   DALI_TEST_CHECK(cornerRadiusValue->Get<Vector4>() == Vector4(10.0f, 10.0f, 10.0f, 10.0f));
510
511   Property::Value* cornerRadiusPolicyValue = resultMap.Find(DevelVisual::Property::CORNER_RADIUS_POLICY, Property::INTEGER);
512   DALI_TEST_CHECK(cornerRadiusPolicyValue);
513   DALI_TEST_CHECK(cornerRadiusPolicyValue->Get<int>() == Toolkit::Visual::Transform::Policy::RELATIVE);
514
515   Property::Value* borderlineWidthValue = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
516   DALI_TEST_CHECK(borderlineWidthValue);
517   DALI_TEST_CHECK(borderlineWidthValue->Get<float>() == 20.0f);
518
519   Property::Value* borderlineColorValue = resultMap.Find(DevelVisual::Property::BORDERLINE_COLOR, Property::VECTOR4);
520   DALI_TEST_CHECK(borderlineColorValue);
521   DALI_TEST_CHECK(borderlineColorValue->Get<Vector4>() == Color::RED);
522
523   Property::Value* borderlineOffsetValue = resultMap.Find(DevelVisual::Property::BORDERLINE_OFFSET, Property::FLOAT);
524   DALI_TEST_CHECK(borderlineOffsetValue);
525   DALI_TEST_CHECK(borderlineOffsetValue->Get<float>() == -1.0f);
526
527   Property::Value* blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
528   DALI_TEST_CHECK(blurRadiusValue);
529   DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 20.0f);
530
531   // change the blend color
532   propertyMap[ColorVisual::Property::MIX_COLOR] = Color::CYAN;
533   colorVisual                                   = factory.CreateVisual(propertyMap);
534   colorVisual.CreatePropertyMap(resultMap);
535
536   colorValue = resultMap.Find(ColorVisual::Property::MIX_COLOR, Property::VECTOR4);
537   DALI_TEST_CHECK(colorValue);
538   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
539
540   // Test wrong values
541   propertyMap[DevelColorVisual::Property::BLUR_RADIUS] = "3.0f";
542
543   colorVisual = factory.CreateVisual(propertyMap);
544   colorVisual.CreatePropertyMap(resultMap);
545
546   blurRadiusValue = resultMap.Find(DevelColorVisual::Property::BLUR_RADIUS, Property::FLOAT);
547   DALI_TEST_CHECK(blurRadiusValue);
548   DALI_TEST_CHECK(blurRadiusValue->Get<float>() == 0.0f);
549
550   END_TEST;
551 }
552
553 int UtcDaliVisualGetPropertyMap2(void)
554 {
555   ToolkitTestApplication application;
556   tet_infoline("UtcDaliVisualGetPropertyMap2: BorderVisual");
557
558   VisualFactory factory = VisualFactory::Get();
559   Property::Map propertyMap;
560   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
561   propertyMap.Insert("mixColor", Vector4(1.0f, 0.0f, 1.0f, 0.5f));
562   propertyMap.Insert("borderColor", Color::BLUE);
563   propertyMap.Insert("borderSize", 5.f);
564   propertyMap.Insert("antiAliasing", true);
565   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
566
567   Property::Map resultMap;
568   borderVisual.CreatePropertyMap(resultMap);
569
570   // check the property values from the returned map from visual
571   Property::Value* typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
572   DALI_TEST_CHECK(typeValue);
573   DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
574
575   Property::Value* colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
576   DALI_TEST_CHECK(colorValue);
577   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::BLUE);
578
579   Property::Value* sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
580   DALI_TEST_CHECK(sizeValue);
581   DALI_TEST_CHECK(sizeValue->Get<float>() == 5.f);
582
583   Property::Value* AAValue = resultMap.Find(BorderVisual::Property::ANTI_ALIASING, Property::BOOLEAN);
584   DALI_TEST_CHECK(AAValue);
585   DALI_TEST_CHECK(AAValue->Get<bool>() == true);
586
587   Property::Map propertyMap1;
588   propertyMap1[Toolkit::Visual::Property::TYPE] = Visual::BORDER;
589   propertyMap1[BorderVisual::Property::COLOR]   = Color::CYAN;
590   propertyMap1[BorderVisual::Property::SIZE]    = 10.0f;
591   borderVisual                                  = factory.CreateVisual(propertyMap1);
592   borderVisual.CreatePropertyMap(resultMap);
593
594   typeValue = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
595   DALI_TEST_CHECK(typeValue);
596   DALI_TEST_CHECK(typeValue->Get<int>() == Visual::BORDER);
597
598   colorValue = resultMap.Find(BorderVisual::Property::COLOR, Property::VECTOR4);
599   DALI_TEST_CHECK(colorValue);
600   DALI_TEST_CHECK(colorValue->Get<Vector4>() == Color::CYAN);
601
602   sizeValue = resultMap.Find(BorderVisual::Property::SIZE, Property::FLOAT);
603   DALI_TEST_CHECK(sizeValue);
604   DALI_TEST_CHECK(sizeValue->Get<float>() == 10.f);
605
606   END_TEST;
607 }
608
609 int UtcDaliVisualGetPropertyMap2N(void)
610 {
611   ToolkitTestApplication application;
612   tet_infoline("UtcDaliVisualGetPropertyMap2N: BorderVisual with no setup properties");
613
614   VisualFactory factory = VisualFactory::Get();
615   Property::Map propertyMap;
616   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
617   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
618
619   tet_infoline("Test that the visual is created, with a default renderer");
620   DALI_TEST_CHECK(borderVisual);
621
622   DummyControl        dummyControl = DummyControl::New(true);
623   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
624   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
625   application.GetScene().Add(dummyControl);
626
627   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
628
629   END_TEST;
630 }
631
632 int UtcDaliVisualGetPropertyMap3(void)
633 {
634   ToolkitTestApplication application;
635   tet_infoline("UtcDaliVisualGetPropertyMap3: linear GradientVisual");
636
637   VisualFactory factory = VisualFactory::Get();
638   DALI_TEST_CHECK(factory);
639
640   Property::Map propertyMap;
641   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
642
643   Vector2 start(-1.f, -1.f);
644   Vector2 end(1.f, 1.f);
645   propertyMap.Insert("startPosition", start);
646   propertyMap.Insert("endPosition", end);
647   propertyMap.Insert("spreadMethod", GradientVisual::SpreadMethod::REPEAT);
648
649   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector2(0.2f, 0.8f));
650
651   Property::Array stopColors;
652   stopColors.PushBack(Color::RED);
653   stopColors.PushBack(Color::GREEN);
654   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
655
656   float   borderlineWidth = 4.0f;
657   Vector4 cornerRadius(7.0f, 10.0f, 13.0f, 16.0f);
658   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
659   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
660
661   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
662
663   Property::Map resultMap;
664   gradientVisual.CreatePropertyMap(resultMap);
665
666   // check the property values from the returned map from visual
667   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
668   DALI_TEST_CHECK(value);
669   DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
670
671   value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
672   DALI_TEST_CHECK(value);
673   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::OBJECT_BOUNDING_BOX);
674
675   value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
676   DALI_TEST_CHECK(value);
677   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::REPEAT);
678
679   value = resultMap.Find(GradientVisual::Property::START_POSITION, Property::VECTOR2);
680   DALI_TEST_CHECK(value);
681   DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
682
683   value = resultMap.Find(GradientVisual::Property::END_POSITION, Property::VECTOR2);
684   DALI_TEST_CHECK(value);
685   DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
686
687   value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
688   DALI_TEST_CHECK(value);
689   DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
690
691   value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
692   DALI_TEST_CHECK(value);
693   DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
694
695   value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
696   DALI_TEST_CHECK(value);
697   Property::Array* offsetArray = value->GetArray();
698   DALI_TEST_CHECK(offsetArray->Count() == 2);
699   DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.2f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
700   DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.8f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
701
702   value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
703   DALI_TEST_CHECK(value);
704   Property::Array* colorArray = value->GetArray();
705   DALI_TEST_CHECK(colorArray->Count() == 2);
706   DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
707   DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
708
709   END_TEST;
710 }
711
712 int UtcDaliVisualGetPropertyMap4(void)
713 {
714   ToolkitTestApplication application;
715   tet_infoline("UtcDaliVisualGetPropertyMap4: radial GradientVisual");
716
717   VisualFactory factory = VisualFactory::Get();
718   DALI_TEST_CHECK(factory);
719
720   Property::Map propertyMap;
721   propertyMap.Insert(Visual::Property::TYPE, Visual::GRADIENT);
722
723   Vector2 center(100.f, 100.f);
724   float   radius = 100.f;
725   propertyMap.Insert(GradientVisual::Property::UNITS, GradientVisual::Units::USER_SPACE);
726   propertyMap.Insert(GradientVisual::Property::CENTER, center);
727   propertyMap.Insert(GradientVisual::Property::RADIUS, radius);
728   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, Vector3(0.1f, 0.3f, 1.1f));
729
730   Property::Array stopColors;
731   stopColors.PushBack(Color::RED);
732   stopColors.PushBack(Color::BLACK);
733   stopColors.PushBack(Color::GREEN);
734   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
735
736   float   borderlineWidth = 8.0f;
737   Vector4 cornerRadius(1.0f, 2.0f, 4.0f, 8.0f);
738   propertyMap.Insert(DevelVisual::Property::BORDERLINE_WIDTH, borderlineWidth);
739   propertyMap.Insert(DevelVisual::Property::CORNER_RADIUS, cornerRadius);
740
741   Visual::Base gradientVisual = factory.CreateVisual(propertyMap);
742   DALI_TEST_CHECK(gradientVisual);
743
744   Property::Map resultMap;
745   gradientVisual.CreatePropertyMap(resultMap);
746
747   // check the property values from the returned map from visual
748   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
749   DALI_TEST_CHECK(value);
750   DALI_TEST_CHECK(value->Get<int>() == Visual::GRADIENT);
751
752   value = resultMap.Find(GradientVisual::Property::UNITS, Property::INTEGER);
753   DALI_TEST_CHECK(value);
754   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::Units::USER_SPACE);
755
756   value = resultMap.Find(GradientVisual::Property::SPREAD_METHOD, Property::INTEGER);
757   DALI_TEST_CHECK(value);
758   DALI_TEST_CHECK(value->Get<int>() == GradientVisual::SpreadMethod::PAD);
759
760   value = resultMap.Find(GradientVisual::Property::CENTER, Property::VECTOR2);
761   DALI_TEST_CHECK(value);
762   DALI_TEST_EQUALS(value->Get<Vector2>(), center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
763
764   value = resultMap.Find(GradientVisual::Property::RADIUS, Property::FLOAT);
765   DALI_TEST_CHECK(value);
766   DALI_TEST_EQUALS(value->Get<float>(), radius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
767
768   value = resultMap.Find(DevelVisual::Property::BORDERLINE_WIDTH, Property::FLOAT);
769   DALI_TEST_CHECK(value);
770   DALI_TEST_EQUALS(value->Get<float>(), borderlineWidth, Math::MACHINE_EPSILON_100, TEST_LOCATION);
771
772   value = resultMap.Find(DevelVisual::Property::CORNER_RADIUS, Property::VECTOR4);
773   DALI_TEST_CHECK(value);
774   DALI_TEST_EQUALS(value->Get<Vector4>(), cornerRadius, Math::MACHINE_EPSILON_100, TEST_LOCATION);
775
776   value = resultMap.Find(GradientVisual::Property::STOP_OFFSET, Property::ARRAY);
777   DALI_TEST_CHECK(value);
778   Property::Array* offsetArray = value->GetArray();
779   DALI_TEST_CHECK(offsetArray->Count() == 3);
780   DALI_TEST_EQUALS(offsetArray->GetElementAt(0).Get<float>(), 0.1f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
781   DALI_TEST_EQUALS(offsetArray->GetElementAt(1).Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
782   // any stop value will be clamped to [0.0, 1.0];
783   DALI_TEST_EQUALS(offsetArray->GetElementAt(2).Get<float>(), 1.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
784
785   value = resultMap.Find(GradientVisual::Property::STOP_COLOR, Property::ARRAY);
786   DALI_TEST_CHECK(value);
787   Property::Array* colorArray = value->GetArray();
788   DALI_TEST_CHECK(colorArray->Count() == 3);
789   DALI_TEST_EQUALS(colorArray->GetElementAt(0).Get<Vector4>(), Color::RED, Math::MACHINE_EPSILON_100, TEST_LOCATION);
790   DALI_TEST_EQUALS(colorArray->GetElementAt(1).Get<Vector4>(), Color::BLACK, Math::MACHINE_EPSILON_100, TEST_LOCATION);
791   DALI_TEST_EQUALS(colorArray->GetElementAt(2).Get<Vector4>(), Color::GREEN, Math::MACHINE_EPSILON_100, TEST_LOCATION);
792
793   END_TEST;
794 }
795
796 int UtcDaliVisualGetPropertyMap5(void)
797 {
798   ToolkitTestApplication application;
799   tet_infoline("UtcDaliVisualGetPropertyMap5: ImageVisual");
800
801   VisualFactory factory = VisualFactory::Get();
802   Property::Map propertyMap;
803   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::IMAGE);
804   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
805   propertyMap.Insert(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME);
806   propertyMap.Insert(ImageVisual::Property::DESIRED_WIDTH, 20);
807   propertyMap.Insert(ImageVisual::Property::DESIRED_HEIGHT, 30);
808   propertyMap.Insert("fittingMode", FittingMode::FIT_HEIGHT);
809   propertyMap.Insert("samplingMode", SamplingMode::BOX_THEN_NEAREST);
810   propertyMap.Insert("pixelArea", Vector4(0.25f, 0.25f, 0.5f, 0.5f));
811   propertyMap.Insert("wrapModeU", WrapMode::REPEAT);
812   propertyMap.Insert("wrapModeV", WrapMode::MIRRORED_REPEAT);
813   propertyMap.Insert("synchronousLoading", true);
814
815   Visual::Base imageVisual = factory.CreateVisual(propertyMap);
816   DALI_TEST_CHECK(imageVisual);
817
818   Property::Map resultMap;
819   imageVisual.CreatePropertyMap(resultMap);
820
821   // check the property values from the returned map from visual
822   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
823   DALI_TEST_CHECK(value);
824   DALI_TEST_CHECK(value->Get<int>() == Visual::IMAGE);
825
826   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
827   DALI_TEST_CHECK(value);
828   DALI_TEST_CHECK(value->Get<std::string>() == TEST_IMAGE_FILE_NAME);
829
830   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
831   DALI_TEST_CHECK(value);
832   DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
833
834   value = resultMap.Find(ImageVisual::Property::FITTING_MODE, Property::INTEGER);
835   DALI_TEST_CHECK(value);
836   DALI_TEST_CHECK(value->Get<int>() == FittingMode::FIT_HEIGHT);
837
838   value = resultMap.Find(ImageVisual::Property::SAMPLING_MODE, Property::INTEGER);
839   DALI_TEST_CHECK(value);
840   DALI_TEST_CHECK(value->Get<int>() == SamplingMode::BOX_THEN_NEAREST);
841
842   value = resultMap.Find(ImageVisual::Property::DESIRED_WIDTH, Property::INTEGER);
843   DALI_TEST_CHECK(value);
844   DALI_TEST_CHECK(value->Get<int>() == 20);
845
846   value = resultMap.Find(ImageVisual::Property::DESIRED_HEIGHT, Property::INTEGER);
847   DALI_TEST_CHECK(value);
848   DALI_TEST_CHECK(value->Get<int>() == 30);
849
850   value = resultMap.Find(ImageVisual::Property::PIXEL_AREA, Property::VECTOR4);
851   DALI_TEST_CHECK(value);
852   DALI_TEST_EQUALS(value->Get<Vector4>(), Vector4(0.25f, 0.25f, 0.5f, 0.5f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
853
854   value = resultMap.Find(ImageVisual::Property::WRAP_MODE_U, Property::INTEGER);
855   DALI_TEST_CHECK(value);
856   DALI_TEST_CHECK(value->Get<int>() == WrapMode::REPEAT);
857
858   value = resultMap.Find(ImageVisual::Property::WRAP_MODE_V, Property::INTEGER);
859   DALI_TEST_CHECK(value);
860   DALI_TEST_CHECK(value->Get<int>() == WrapMode::MIRRORED_REPEAT);
861
862   value = resultMap.Find(ImageVisual::Property::SYNCHRONOUS_LOADING, Property::BOOLEAN);
863   DALI_TEST_CHECK(value);
864   DALI_TEST_CHECK(value->Get<bool>() == true);
865
866   END_TEST;
867 }
868
869 int UtcDaliVisualGetPropertyMap6(void)
870 {
871   ToolkitTestApplication application;
872   tet_infoline("UtcDaliVisualGetPropertyMap6: NPatchVisual");
873
874   Rect<int> border(1, 1, 1, 1);
875
876   VisualFactory factory = VisualFactory::Get();
877   Property::Map propertyMap;
878   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
879   propertyMap.Insert("mixColor", Color::MAGENTA);
880   propertyMap.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
881   propertyMap.Insert(ImageVisual::Property::BORDER_ONLY, true);
882   propertyMap.Insert(ImageVisual::Property::BORDER, border);
883   propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE, "application-icon-30.png");
884   propertyMap.Insert(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, 0.9f);
885   Visual::Base nPatchVisual = factory.CreateVisual(propertyMap);
886
887   Property::Map resultMap;
888   nPatchVisual.CreatePropertyMap(resultMap);
889
890   // check the property values from the returned map from visual
891   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
892   DALI_TEST_CHECK(value);
893   DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
894
895   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
896   DALI_TEST_CHECK(value);
897   DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
898
899   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
900   DALI_TEST_CHECK(value);
901   DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
902
903   value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
904   DALI_TEST_CHECK(value);
905   DALI_TEST_CHECK(value->Get<bool>());
906
907   value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
908   DALI_TEST_CHECK(value);
909   DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
910
911   value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE, Property::STRING);
912   DALI_TEST_CHECK(value);
913   DALI_TEST_CHECK(value->Get<std::string>() == "application-icon-30.png");
914
915   value = resultMap.Find(DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA, Property::FLOAT);
916   DALI_TEST_CHECK(value);
917   DALI_TEST_CHECK(value->Get<float>() == 0.9f);
918
919   Vector4 border1(1.0f, 1.0f, 1.0f, 1.0f);
920
921   Property::Map propertyMap1;
922   propertyMap1.Insert(Toolkit::Visual::Property::TYPE, Visual::N_PATCH);
923   propertyMap1.Insert("mixColor", Color::MAGENTA);
924   propertyMap1.Insert(ImageVisual::Property::URL, TEST_NPATCH_FILE_NAME);
925   propertyMap1.Insert(ImageVisual::Property::BORDER_ONLY, true);
926   propertyMap1.Insert(ImageVisual::Property::BORDER, border1);
927   nPatchVisual = factory.CreateVisual(propertyMap1);
928
929   nPatchVisual.CreatePropertyMap(resultMap);
930
931   // check the property values from the returned map from visual
932   value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
933   DALI_TEST_CHECK(value);
934   DALI_TEST_CHECK(value->Get<int>() == Visual::N_PATCH);
935
936   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
937   DALI_TEST_CHECK(value);
938   DALI_TEST_CHECK(value->Get<Vector4>() == Color::MAGENTA);
939
940   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
941   DALI_TEST_CHECK(value);
942   DALI_TEST_CHECK(value->Get<std::string>() == TEST_NPATCH_FILE_NAME);
943
944   value = resultMap.Find(ImageVisual::Property::BORDER_ONLY, Property::BOOLEAN);
945   DALI_TEST_CHECK(value);
946   DALI_TEST_CHECK(value->Get<bool>());
947
948   value = resultMap.Find(ImageVisual::Property::BORDER, Property::RECTANGLE);
949   DALI_TEST_CHECK(value);
950   DALI_TEST_CHECK(value->Get<Rect<int> >() == border);
951
952   END_TEST;
953 }
954
955 int UtcDaliVisualGetPropertyMap7(void)
956 {
957   ToolkitTestApplication application;
958   tet_infoline("UtcDaliVisualGetPropertyMap7: SvgVisual");
959
960   // request SvgVisual with a property map
961   VisualFactory factory = VisualFactory::Get();
962   Property::Map propertyMap;
963   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::SVG);
964   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::WHITE);
965   propertyMap.Insert(ImageVisual::Property::URL, TEST_SVG_FILE_NAME);
966   propertyMap.Insert(ImageVisual::Property::ATLASING, false);
967   Visual::Base svgVisual = factory.CreateVisual(propertyMap);
968
969   Property::Map resultMap;
970   svgVisual.CreatePropertyMap(resultMap);
971   // check the property values from the returned map from a visual
972   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
973   DALI_TEST_CHECK(value);
974   DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
975
976   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
977   DALI_TEST_CHECK(value);
978   DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
979
980   value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
981   DALI_TEST_CHECK(value);
982   DALI_TEST_CHECK(value->Get<bool>() == false);
983
984   // request SvgVisual with a property map 2
985   propertyMap.Clear();
986   propertyMap["visualType"] = Visual::SVG;
987   propertyMap["mixColor"]   = Color::WHITE;
988   propertyMap["url"]        = TEST_SVG_FILE_NAME;
989   propertyMap["atlasing"]   = true;
990   Visual::Base svgVisual1   = factory.CreateVisual(propertyMap);
991
992   resultMap.Clear();
993   svgVisual1.CreatePropertyMap(resultMap);
994   // check the property values from the returned map from a visual
995   value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
996   DALI_TEST_CHECK(value);
997   DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
998
999   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1000   DALI_TEST_CHECK(value);
1001   DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1002
1003   value = resultMap.Find(ImageVisual::Property::ATLASING, Property::BOOLEAN);
1004   DALI_TEST_CHECK(value);
1005   DALI_TEST_CHECK(value->Get<bool>() == true);
1006
1007   // request SvgVisual with an URL
1008   Visual::Base svgVisual2 = factory.CreateVisual(TEST_SVG_FILE_NAME, ImageDimensions());
1009   resultMap.Clear();
1010   svgVisual2.CreatePropertyMap(resultMap);
1011   // check the property values from the returned map from a visual
1012   value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1013   DALI_TEST_CHECK(value);
1014   DALI_TEST_CHECK(value->Get<int>() == Visual::SVG);
1015
1016   value = resultMap.Find(ImageVisual::Property::URL, Property::STRING);
1017   DALI_TEST_CHECK(value);
1018   DALI_TEST_CHECK(value->Get<std::string>() == TEST_SVG_FILE_NAME);
1019
1020   END_TEST;
1021 }
1022
1023 //Mesh visual
1024 int UtcDaliVisualGetPropertyMap8(void)
1025 {
1026   ToolkitTestApplication application;
1027   tet_infoline("UtcDaliVisualGetPropertyMap8: MeshVisual");
1028
1029   //Request MeshVisual using a property map.
1030   VisualFactory factory = VisualFactory::Get();
1031   Property::Map propertyMap;
1032   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
1033   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLUE);
1034   propertyMap.Insert(MeshVisual::Property::OBJECT_URL, TEST_OBJ_FILE_NAME);
1035   propertyMap.Insert(MeshVisual::Property::MATERIAL_URL, TEST_MTL_FILE_NAME);
1036   propertyMap.Insert(MeshVisual::Property::TEXTURES_PATH, TEST_RESOURCE_LOCATION);
1037   propertyMap.Insert(MeshVisual::Property::SHADING_MODE, MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
1038   propertyMap.Insert(MeshVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1039   Visual::Base meshVisual = factory.CreateVisual(propertyMap);
1040
1041   Property::Map resultMap;
1042   meshVisual.CreatePropertyMap(resultMap);
1043   TestMixColor(meshVisual, Visual::Property::MIX_COLOR, Color::BLUE);
1044
1045   //Check values in the result map are identical to the initial map's values.
1046   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1047   DALI_TEST_CHECK(value);
1048   DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::MESH, TEST_LOCATION);
1049
1050   value = resultMap.Find(MeshVisual::Property::OBJECT_URL, Property::STRING);
1051   DALI_TEST_CHECK(value);
1052   DALI_TEST_EQUALS(value->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION);
1053
1054   value = resultMap.Find(MeshVisual::Property::MATERIAL_URL, Property::STRING);
1055   DALI_TEST_CHECK(value);
1056   DALI_TEST_EQUALS(value->Get<std::string>(), TEST_MTL_FILE_NAME, TEST_LOCATION);
1057
1058   value = resultMap.Find(MeshVisual::Property::TEXTURES_PATH, Property::STRING);
1059   DALI_TEST_CHECK(value);
1060   DALI_TEST_EQUALS(value->Get<std::string>(), TEST_RESOURCE_LOCATION, TEST_LOCATION);
1061
1062   value = resultMap.Find(MeshVisual::Property::SHADING_MODE, Property::INTEGER);
1063   DALI_TEST_CHECK(value);
1064   DALI_TEST_EQUALS(value->Get<int>(), (int)MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING, TEST_LOCATION);
1065
1066   value = resultMap.Find(MeshVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1067   DALI_TEST_CHECK(value);
1068   DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1069
1070   END_TEST;
1071 }
1072
1073 //Primitive shape visual
1074 int UtcDaliVisualGetPropertyMap9(void)
1075 {
1076   ToolkitTestApplication application;
1077   tet_infoline("UtcDaliVisualGetPropertyMap9: PrimitiveVisual");
1078
1079   static std::vector<UniformData> customUniforms =
1080     {
1081       UniformData("mixColor", Property::Type::VECTOR3),
1082     };
1083
1084   TestGraphicsController& graphics = application.GetGraphicsController();
1085   graphics.AddCustomUniforms(customUniforms);
1086
1087   Vector4 color      = Vector4(1.0, 0.8, 0.6, 1.0);
1088   Vector3 dimensions = Vector3(1.0, 2.0, 3.0);
1089
1090   //Request PrimitiveVisual using a property map.
1091   VisualFactory factory = VisualFactory::Get();
1092   Property::Map propertyMap;
1093   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::PRIMITIVE);
1094   propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
1095   propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, color);
1096   propertyMap.Insert(PrimitiveVisual::Property::SLICES, 10);
1097   propertyMap.Insert(PrimitiveVisual::Property::STACKS, 20);
1098   propertyMap.Insert(PrimitiveVisual::Property::SCALE_TOP_RADIUS, 30.0f);
1099   propertyMap.Insert(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, 40.0f);
1100   propertyMap.Insert(PrimitiveVisual::Property::SCALE_HEIGHT, 50.0f);
1101   propertyMap.Insert(PrimitiveVisual::Property::SCALE_RADIUS, 60.0f);
1102   propertyMap.Insert(PrimitiveVisual::Property::SCALE_DIMENSIONS, dimensions);
1103   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_PERCENTAGE, 0.3f);
1104   propertyMap.Insert(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, 0.6f);
1105   propertyMap.Insert(PrimitiveVisual::Property::LIGHT_POSITION, Vector3(5.0f, 10.0f, 15.0f));
1106   Visual::Base primitiveVisual = factory.CreateVisual(propertyMap);
1107
1108   Property::Map resultMap;
1109   primitiveVisual.CreatePropertyMap(resultMap);
1110
1111   //Check values in the result map are identical to the initial map's values.
1112   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1113   DALI_TEST_CHECK(value);
1114   DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::PRIMITIVE, TEST_LOCATION);
1115
1116   value = resultMap.Find(PrimitiveVisual::Property::SHAPE, Property::INTEGER);
1117   DALI_TEST_CHECK(value);
1118   DALI_TEST_EQUALS(value->Get<int>(), (int)PrimitiveVisual::Shape::CUBE, TEST_LOCATION);
1119
1120   value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1121   DALI_TEST_CHECK(value);
1122   DALI_TEST_CHECK(value->Get<Vector4>() == color);
1123   DALI_TEST_EQUALS(value->Get<Vector4>(), color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1124
1125   value = resultMap.Find(PrimitiveVisual::Property::SLICES, Property::INTEGER);
1126   DALI_TEST_CHECK(value);
1127   DALI_TEST_EQUALS(value->Get<int>(), 10, TEST_LOCATION);
1128
1129   value = resultMap.Find(PrimitiveVisual::Property::STACKS, Property::INTEGER);
1130   DALI_TEST_CHECK(value);
1131   DALI_TEST_EQUALS(value->Get<int>(), 20, TEST_LOCATION);
1132
1133   value = resultMap.Find(PrimitiveVisual::Property::SCALE_TOP_RADIUS, Property::FLOAT);
1134   DALI_TEST_CHECK(value);
1135   DALI_TEST_EQUALS(value->Get<float>(), 30.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1136
1137   value = resultMap.Find(PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS, Property::FLOAT);
1138   DALI_TEST_CHECK(value);
1139   DALI_TEST_EQUALS(value->Get<float>(), 40.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1140
1141   value = resultMap.Find(PrimitiveVisual::Property::SCALE_HEIGHT, Property::FLOAT);
1142   DALI_TEST_CHECK(value);
1143   DALI_TEST_EQUALS(value->Get<float>(), 50.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1144
1145   value = resultMap.Find(PrimitiveVisual::Property::SCALE_RADIUS, Property::FLOAT);
1146   DALI_TEST_CHECK(value);
1147   DALI_TEST_EQUALS(value->Get<float>(), 60.0f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1148
1149   value = resultMap.Find(PrimitiveVisual::Property::SCALE_DIMENSIONS, Property::VECTOR3);
1150   DALI_TEST_CHECK(value);
1151   DALI_TEST_EQUALS(value->Get<Vector3>(), dimensions, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1152
1153   value = resultMap.Find(PrimitiveVisual::Property::BEVEL_PERCENTAGE, Property::FLOAT);
1154   DALI_TEST_CHECK(value);
1155   DALI_TEST_EQUALS(value->Get<float>(), 0.3f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1156
1157   value = resultMap.Find(PrimitiveVisual::Property::BEVEL_SMOOTHNESS, Property::FLOAT);
1158   DALI_TEST_CHECK(value);
1159   DALI_TEST_EQUALS(value->Get<float>(), 0.6f, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1160
1161   value = resultMap.Find(PrimitiveVisual::Property::LIGHT_POSITION, Property::VECTOR3);
1162   DALI_TEST_CHECK(value);
1163   DALI_TEST_EQUALS(value->Get<Vector3>(), Vector3(5.0f, 10.0f, 15.0f), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1164
1165   DummyControl        actor     = DummyControl::New(true);
1166   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1167   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, primitiveVisual);
1168   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1169   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1170   application.GetScene().Add(actor);
1171
1172   Animation animation = Animation::New(1.0f);
1173   animation.AnimateTo(DevelControl::GetVisualProperty(actor, DummyControl::Property::TEST_VISUAL, PrimitiveVisual::Property::MIX_COLOR), Vector3(Color::MAGENTA));
1174   animation.Play();
1175   application.SendNotification();
1176   application.Render(0);
1177   application.Render(1000);
1178   application.SendNotification();
1179
1180   auto& gl = application.GetGlAbstraction();
1181   DALI_TEST_EQUALS(gl.CheckUniformValue<Vector3>("mixColor", Vector3(Color::MAGENTA)), true, TEST_LOCATION);
1182
1183   tet_infoline("Check property map after animation");
1184
1185   primitiveVisual.CreatePropertyMap(resultMap);
1186   value = resultMap.Find(PrimitiveVisual::Property::MIX_COLOR, Property::VECTOR4);
1187   DALI_TEST_CHECK(value);
1188   color = value->Get<Vector4>();
1189   // Ignore alpha part
1190   DALI_TEST_EQUALS(Vector3(color), Vector3(Color::MAGENTA), 0.001f, TEST_LOCATION);
1191
1192   END_TEST;
1193 }
1194
1195 //Text shape visual
1196 int UtcDaliVisualGetPropertyMap10(void)
1197 {
1198   ToolkitTestApplication application;
1199   tet_infoline("UtcDaliVisualGetPropertyMap10: TextVisual");
1200
1201   //Request PrimitiveVisual using a property map.
1202   VisualFactory factory = VisualFactory::Get();
1203
1204   Property::Map propertyMap;
1205   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
1206   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::BLACK);
1207   propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
1208   propertyMap.Insert("enableMarkup", false);
1209   propertyMap.Insert("text", "Hello world");
1210   propertyMap.Insert("fontFamily", "TizenSans");
1211
1212   Property::Map fontStyleMapSet;
1213   fontStyleMapSet.Insert("weight", "bold");
1214   propertyMap.Insert("fontStyle", fontStyleMapSet);
1215
1216   propertyMap.Insert("pointSize", 12.f);
1217   propertyMap.Insert("multiLine", true);
1218   propertyMap.Insert("horizontalAlignment", "CENTER");
1219   propertyMap.Insert("verticalAlignment", "CENTER");
1220   propertyMap.Insert("textColor", Color::RED);
1221
1222   Property::Map shadowMapSet;
1223   propertyMap.Insert("shadow", shadowMapSet.Add("color", Color::RED).Add("offset", Vector2(2.0f, 2.0f)).Add("blurRadius", 3.0f));
1224
1225   Property::Map underlineMapSet;
1226   propertyMap.Insert("underline", underlineMapSet.Add("enable", true).Add("color", Color::GREEN).Add("height", 1).Add("type", Text::Underline::Type::SOLID).Add("dashWidth", 2).Add("dashGap", 1));
1227
1228   Property::Map outlineMapSet;
1229   propertyMap.Insert("outline", outlineMapSet.Add("color", Color::YELLOW).Add("width", 1));
1230
1231   Property::Map backgroundMapSet;
1232   propertyMap.Insert("textBackground", backgroundMapSet.Add("enable", true).Add("color", Color::CYAN));
1233
1234   Visual::Base textVisual = factory.CreateVisual(propertyMap);
1235
1236   Property::Map resultMap;
1237   textVisual.CreatePropertyMap(resultMap);
1238
1239   //Check values in the result map are identical to the initial map's values.
1240   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1241   DALI_TEST_CHECK(value);
1242   DALI_TEST_EQUALS(value->Get<int>(), (int)Visual::TEXT, TEST_LOCATION);
1243
1244   value = resultMap.Find(Visual::Property::MIX_COLOR, Property::VECTOR4);
1245   DALI_TEST_CHECK(value);
1246   DALI_TEST_EQUALS(value->Get<Vector4>(), Color::BLACK, 0.001f, TEST_LOCATION);
1247
1248   value = resultMap.Find(TextVisual::Property::TEXT, Property::STRING);
1249   DALI_TEST_CHECK(value);
1250   DALI_TEST_EQUALS(value->Get<std::string>(), "Hello world", TEST_LOCATION);
1251
1252   value = resultMap.Find(TextVisual::Property::FONT_FAMILY, Property::STRING);
1253   DALI_TEST_CHECK(value);
1254   DALI_TEST_EQUALS(value->Get<std::string>(), "TizenSans", TEST_LOCATION);
1255
1256   value = resultMap.Find(TextVisual::Property::FONT_STYLE, Property::MAP);
1257   DALI_TEST_CHECK(value);
1258
1259   Property::Map fontStyleMapGet = value->Get<Property::Map>();
1260   DALI_TEST_EQUALS(fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION);
1261   DALI_TEST_EQUALS(DaliTestCheckMaps(fontStyleMapGet, fontStyleMapSet), true, TEST_LOCATION);
1262
1263   value = resultMap.Find(TextVisual::Property::POINT_SIZE, Property::FLOAT);
1264   DALI_TEST_CHECK(value);
1265   DALI_TEST_EQUALS(value->Get<float>(), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
1266
1267   value = resultMap.Find(TextVisual::Property::MULTI_LINE, Property::BOOLEAN);
1268   DALI_TEST_CHECK(value);
1269   DALI_TEST_CHECK(value->Get<bool>());
1270
1271   value = resultMap.Find(TextVisual::Property::HORIZONTAL_ALIGNMENT, Property::INTEGER);
1272   DALI_TEST_CHECK(value);
1273   DALI_TEST_EQUALS(value->Get<int>(), (int)Text::HorizontalAlignment::CENTER, TEST_LOCATION);
1274
1275   value = resultMap.Find(TextVisual::Property::VERTICAL_ALIGNMENT, Property::INTEGER);
1276   DALI_TEST_CHECK(value);
1277   DALI_TEST_EQUALS(value->Get<int>(), (int)Text::VerticalAlignment::CENTER, TEST_LOCATION);
1278
1279   value = resultMap.Find(TextVisual::Property::TEXT_COLOR, Property::VECTOR4);
1280   DALI_TEST_CHECK(value);
1281   DALI_TEST_EQUALS(value->Get<Vector4>(), Color::RED, TEST_LOCATION);
1282
1283   value = resultMap.Find(TextVisual::Property::ENABLE_MARKUP, Property::BOOLEAN);
1284   DALI_TEST_CHECK(value);
1285   DALI_TEST_CHECK(!value->Get<bool>());
1286
1287   value = resultMap.Find(TextVisual::Property::SHADOW, Property::MAP);
1288   DALI_TEST_CHECK(value);
1289
1290   Property::Map shadowMapGet = value->Get<Property::Map>();
1291   DALI_TEST_EQUALS(shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION);
1292   DALI_TEST_EQUALS(DaliTestCheckMaps(shadowMapGet, shadowMapSet), true, TEST_LOCATION);
1293
1294   value = resultMap.Find(TextVisual::Property::UNDERLINE, Property::MAP);
1295   DALI_TEST_CHECK(value);
1296
1297   Property::Map underlineMapGet = value->Get<Property::Map>();
1298   DALI_TEST_EQUALS(underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION);
1299   DALI_TEST_EQUALS(DaliTestCheckMaps(underlineMapGet, underlineMapSet), true, TEST_LOCATION);
1300
1301   value = resultMap.Find(DevelTextVisual::Property::OUTLINE, Property::MAP);
1302   DALI_TEST_CHECK(value);
1303
1304   Property::Map outlineMapGet = value->Get<Property::Map>();
1305   DALI_TEST_EQUALS(outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION);
1306   DALI_TEST_EQUALS(DaliTestCheckMaps(outlineMapGet, outlineMapSet), true, TEST_LOCATION);
1307
1308   value = resultMap.Find(DevelTextVisual::Property::BACKGROUND, Property::MAP);
1309   DALI_TEST_CHECK(value);
1310
1311   Property::Map backgroundMapGet = value->Get<Property::Map>();
1312   DALI_TEST_EQUALS(backgroundMapGet.Count(), backgroundMapSet.Count(), TEST_LOCATION);
1313   DALI_TEST_EQUALS(DaliTestCheckMaps(backgroundMapGet, backgroundMapSet), true, TEST_LOCATION);
1314
1315   END_TEST;
1316 }
1317
1318 int UtcDaliVisualGetPropertyMap11(void)
1319 {
1320   ToolkitTestApplication application;
1321   tet_infoline("UtcDaliVisualGetPropertyMap11: AnimatedGradientVisual");
1322
1323   VisualFactory factory = VisualFactory::Get();
1324   DALI_TEST_CHECK(factory);
1325
1326   Property::Map propertyMap;
1327   propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1328
1329   Vector2 start(-0.5f, 0.5f);
1330   Vector2 end(0.5f, -0.0f);
1331   Vector4 start_color(1.0f, 0.7f, 0.5f, 1.0f);
1332   Vector4 end_color(0.7f, 0.5f, 1.0f, 1.0f);
1333   Vector2 rotate_center(0.0f, 0.4f);
1334   float   rotate_amount = 1.57f;
1335   float   offset        = 100.f;
1336
1337   propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::RADIAL);
1338   propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1339   propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::CLAMP);
1340
1341   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, start);
1342   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, end);
1343   propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, start_color);
1344   propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, end_color);
1345   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center);
1346   propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount);
1347   propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, offset);
1348
1349   Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1350   DALI_TEST_CHECK(animatedGradientVisual);
1351
1352   Property::Map resultMap;
1353   animatedGradientVisual.CreatePropertyMap(resultMap);
1354
1355   // check the property values from the returned map from visual
1356   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1357   DALI_TEST_CHECK(value);
1358   DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1359
1360   value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1361   DALI_TEST_CHECK(value);
1362   DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1363
1364   value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1365   DALI_TEST_CHECK(value);
1366   DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1367
1368   value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1369   DALI_TEST_CHECK(value);
1370   DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::CLAMP);
1371
1372   value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1373   DALI_TEST_CHECK(value);
1374   DALI_TEST_EQUALS(value->Get<Vector2>(), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1375
1376   value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1377   DALI_TEST_CHECK(value);
1378   DALI_TEST_EQUALS(value->Get<Vector2>(), end, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1379
1380   value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1381   DALI_TEST_CHECK(value);
1382   DALI_TEST_EQUALS(value->Get<Vector4>(), start_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1383
1384   value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1385   DALI_TEST_CHECK(value);
1386   DALI_TEST_EQUALS(value->Get<Vector4>(), end_color, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1387
1388   value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1389   DALI_TEST_CHECK(value);
1390   DALI_TEST_EQUALS(value->Get<Vector2>(), rotate_center, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1391
1392   value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1393   DALI_TEST_CHECK(value);
1394   DALI_TEST_EQUALS(value->Get<float>(), rotate_amount, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1395
1396   value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1397   DALI_TEST_CHECK(value);
1398   DALI_TEST_EQUALS(value->Get<float>(), offset, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1399
1400   END_TEST;
1401 }
1402
1403 int UtcDaliVisualGetPropertyMap12(void)
1404 {
1405   ToolkitTestApplication application;
1406   tet_infoline("UtcDaliVisualGetPropertyMap12: AnimatedGradientVisual with animation param");
1407
1408   // Case 1 : Set values by index
1409   {
1410     tet_printf(" - Set Values by Index\n");
1411     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1412     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1413     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1414     {
1415       tet_printf("test with delay [%f]\n", _delay);
1416       VisualFactory factory = VisualFactory::Get();
1417       DALI_TEST_CHECK(factory);
1418
1419       Property::Map propertyMap;
1420       Property::Map animationMap;
1421       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1422
1423       float duration     = 1.1f;
1424       float delay        = _delay;
1425       float repeat_delay = 0.4f;
1426
1427       int direction  = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1428       int loop_count = 5;
1429       int motion     = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1430       int easing     = DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT;
1431
1432       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1433         animationMap.Clear();
1434         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1435         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1436         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1437         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1438         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1439         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1440         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1441         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1442         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1443
1444         return animationMap;
1445       };
1446
1447       Vector2 start1(-0.5f, 0.5f);
1448       Vector2 end1(0.5f, -0.5f);
1449       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1450       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1451       Vector2 rotate_center1(0.0f, 0.4f);
1452       float   rotate_amount1 = 0.0f;
1453       float   offset1        = 0.f;
1454
1455       Vector2 start2(-0.5f, -0.5f);
1456       Vector2 end2(0.5f, 0.5f);
1457       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1458       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1459       Vector2 rotate_center2(0.0f, -0.4f);
1460       float   rotate_amount2 = 6.2832f;
1461       float   offset2        = 2.f;
1462
1463       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1464       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1465       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REPEAT);
1466
1467       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1468       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1469       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1470       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1471       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1472       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1473       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1474
1475       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1476       DALI_TEST_CHECK(animatedGradientVisual);
1477
1478       Property::Map resultMap;
1479       animatedGradientVisual.CreatePropertyMap(resultMap);
1480
1481       // check the property values from the returned map from visual
1482       Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1483       DALI_TEST_CHECK(value);
1484       DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1485
1486       value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1487       DALI_TEST_CHECK(value);
1488       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1489
1490       value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1491       DALI_TEST_CHECK(value);
1492       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1493
1494       value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1495       DALI_TEST_CHECK(value);
1496       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REPEAT);
1497
1498       auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index& index, const Property::Value& start, const Property::Value& target, int line_num) -> void {
1499         tet_printf("Check value at %d\n", line_num);
1500         value = resultMap.Find(index, Property::MAP);
1501         DALI_TEST_CHECK(value);
1502         DALI_TEST_CHECK(value->GetType() == Property::MAP);
1503         Property::Map* temp_map = value->GetMap();
1504         DALI_TEST_CHECK(temp_map);
1505
1506         auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1507           Property::Value* res = temp_map->Find(index);
1508           DALI_TEST_CHECK(res);
1509           return *res;
1510         };
1511
1512         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1513         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1514         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1515         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1516         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1517         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1518         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1519         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1520         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1521       };
1522
1523       // check the animation map data is good
1524       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1525       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1526       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1527       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1528       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1529       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1530       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1531     }
1532   }
1533
1534   // Case 2 : Set values by string
1535   {
1536     tet_printf(" - Set Values by String\n");
1537     // NOTE : PropertyMap doesn't optimized even delay < -loop_count * (duration + repeat_delay) so this animation will not run
1538     // _delay = -10.0f is this case. It will progress (10.0f / 1.5f) amount. and 10.0f / 1.5f > 5.
1539     for(float _delay = -10.0f; _delay <= 5.0f; _delay += 5.0f)
1540     {
1541       tet_printf("test with delay [%f]\n", _delay);
1542       VisualFactory factory = VisualFactory::Get();
1543       DALI_TEST_CHECK(factory);
1544
1545       Property::Map propertyMap;
1546       Property::Map animationMap;
1547       propertyMap.Insert("visualType", "ANIMATED_GRADIENT");
1548
1549       float duration     = 1.1f;
1550       float delay        = _delay;
1551       float repeat_delay = 0.4f;
1552
1553       int direction  = DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD;
1554       int loop_count = 5;
1555       int motion     = DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR;
1556       int easing     = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT;
1557
1558       auto buildAnimatedMap = [&animationMap, &duration, &delay, &loop_count, &repeat_delay](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1559         animationMap.Clear();
1560         animationMap.Insert("startValue", start);
1561         animationMap.Insert("targetValue", target);
1562         animationMap.Insert("directionType", "BACKWARD");
1563         animationMap.Insert("duration", duration);
1564         animationMap.Insert("delay", delay);
1565         animationMap.Insert("repeat", loop_count);
1566         animationMap.Insert("repeatDelay", repeat_delay);
1567         animationMap.Insert("motionType", "MIRROR");
1568         animationMap.Insert("easingType", "IN_OUT");
1569
1570         return animationMap;
1571       };
1572
1573       Vector2 start1(-0.5f, 0.5f);
1574       Vector2 end1(0.5f, -0.5f);
1575       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1576       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1577       Vector2 rotate_center1(0.0f, 0.4f);
1578       float   rotate_amount1 = 0.0f;
1579       float   offset1        = 0.f;
1580
1581       Vector2 start2(-0.5f, -0.5f);
1582       Vector2 end2(0.5f, 0.5f);
1583       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1584       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1585       Vector2 rotate_center2(0.0f, -0.4f);
1586       float   rotate_amount2 = 6.2832f;
1587       float   offset2        = 2.f;
1588
1589       // For test mix the type string/index key and string/index value works well.
1590       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, "RADIAL");
1591       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1592       propertyMap.Insert("spreadType", DevelAnimatedGradientVisual::SpreadType::REFLECT);
1593
1594       propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2));
1595       propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2));
1596       propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2));
1597       propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2));
1598       propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2));
1599       propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2));
1600       propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2));
1601
1602       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1603       DALI_TEST_CHECK(animatedGradientVisual);
1604
1605       Property::Map resultMap;
1606       animatedGradientVisual.CreatePropertyMap(resultMap);
1607
1608       // check the property values from the returned map from visual
1609       // Note : resultMap from CreatePropertyMap only contain indexKey
1610       Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1611       DALI_TEST_CHECK(value);
1612       DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1613
1614       value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1615       DALI_TEST_CHECK(value);
1616       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::RADIAL);
1617
1618       value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1619       DALI_TEST_CHECK(value);
1620       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::USER_SPACE);
1621
1622       value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1623       DALI_TEST_CHECK(value);
1624       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1625
1626       auto checkAnimatedMap = [&value, &resultMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Index& index, const Property::Value& start, const Property::Value& target, int line_num) -> void {
1627         tet_printf("Check value at %d\n", line_num);
1628         value = resultMap.Find(index, Property::MAP);
1629         DALI_TEST_CHECK(value);
1630         DALI_TEST_CHECK(value->GetType() == Property::MAP);
1631         Property::Map* temp_map = value->GetMap();
1632         DALI_TEST_CHECK(temp_map);
1633
1634         auto checkMapValue = [&temp_map](const Property::Index index) -> Property::Value {
1635           Property::Value* res = temp_map->Find(index);
1636           DALI_TEST_CHECK(res);
1637           return *res;
1638         };
1639
1640         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::START), start, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1641         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET), target, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1642         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION), Property::Value(direction), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1643         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION), Property::Value(duration), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1644         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY), Property::Value(delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1645         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT), Property::Value(loop_count), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1646         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY), Property::Value(repeat_delay), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1647         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE), Property::Value(motion), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1648         DALI_TEST_EQUALS(checkMapValue(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE), Property::Value(easing), Math::MACHINE_EPSILON_100, TEST_LOCATION);
1649       };
1650
1651       // check the animation map data is good
1652       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_POSITION, start1, start2, __LINE__);
1653       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_POSITION, end1, end2, __LINE__);
1654       checkAnimatedMap(DevelAnimatedGradientVisual::Property::START_COLOR, start_color1, start_color2, __LINE__);
1655       checkAnimatedMap(DevelAnimatedGradientVisual::Property::END_COLOR, end_color1, end_color2, __LINE__);
1656       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, rotate_center1, rotate_center2, __LINE__);
1657       checkAnimatedMap(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, rotate_amount1, rotate_amount2, __LINE__);
1658       checkAnimatedMap(DevelAnimatedGradientVisual::Property::OFFSET, offset1, offset2, __LINE__);
1659     }
1660   }
1661
1662   END_TEST;
1663 }
1664 int UtcDaliVisualGetPropertyMap13(void)
1665 {
1666   ToolkitTestApplication application;
1667   tet_infoline("UtcDaliVisualGetPropertyMap13: AnimatedGradientVisual when repeat = 0");
1668
1669   for(int _direction = 0; _direction <= 1; ++_direction)
1670   {
1671     for(float _delay = -10.0f; _delay <= 10.0f; _delay += 10.0f)
1672     {
1673       tet_printf(((_direction == 0) ? "Forward test with delay [%f]\n" : "Backward test with delay [%f]\n"), _delay);
1674       VisualFactory factory = VisualFactory::Get();
1675       DALI_TEST_CHECK(factory);
1676
1677       Property::Map propertyMap;
1678       Property::Map animationMap;
1679       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
1680
1681       float duration     = 1.0f;
1682       float delay        = _delay;
1683       float repeat_delay = 0.5f;
1684
1685       int direction  = _direction;
1686       int loop_count = 0; // When loop_count is 0, Animation will not be created.
1687       int motion     = DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP;
1688       int easing     = DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN;
1689
1690       auto buildAnimatedMap = [&animationMap, &direction, &duration, &delay, &loop_count, &repeat_delay, &motion, &easing](const Property::Value& start, const Property::Value& target) -> Property::Map& {
1691         animationMap.Clear();
1692         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
1693         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
1694         if(direction == 0)
1695           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
1696         else
1697           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
1698         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, direction);
1699         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
1700         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
1701         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
1702         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
1703         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, motion);
1704         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, easing);
1705
1706         return animationMap;
1707       };
1708
1709       Vector2 start1(-0.5f, 0.5f);
1710       Vector2 end1(0.5f, -0.5f);
1711       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
1712       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
1713       Vector2 rotate_center1(1.0f, 0.4f);
1714       float   rotate_amount1 = 2.0f;
1715       float   offset1        = 1.f;
1716
1717       Vector2 start2(-0.5f, -0.5f);
1718       Vector2 end2(0.5f, 0.5f);
1719       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
1720       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
1721       Vector2 rotate_center2(1.0f, -0.4f);
1722       float   rotate_amount2 = 1.0f;
1723       float   offset2        = 3.f;
1724
1725       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, DevelAnimatedGradientVisual::GradientType::LINEAR);
1726       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1727       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, DevelAnimatedGradientVisual::SpreadType::REFLECT);
1728
1729       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2));
1730       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2));
1731       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2));
1732       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2));
1733       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2));
1734       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2));
1735       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2));
1736
1737       Visual::Base animatedGradientVisual = factory.CreateVisual(propertyMap);
1738       DALI_TEST_CHECK(animatedGradientVisual);
1739
1740       Property::Map resultMap;
1741       animatedGradientVisual.CreatePropertyMap(resultMap);
1742
1743       // check the property values from the returned map from visual
1744       Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
1745       DALI_TEST_CHECK(value);
1746       DALI_TEST_CHECK(value->Get<int>() == DevelVisual::ANIMATED_GRADIENT);
1747
1748       value = resultMap.Find(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, Property::INTEGER);
1749       DALI_TEST_CHECK(value);
1750       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::GradientType::LINEAR);
1751
1752       value = resultMap.Find(DevelAnimatedGradientVisual::Property::UNIT_TYPE, Property::INTEGER);
1753       DALI_TEST_CHECK(value);
1754       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::UnitType::OBJECT_BOUNDING_BOX);
1755
1756       value = resultMap.Find(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, Property::INTEGER);
1757       DALI_TEST_CHECK(value);
1758       DALI_TEST_CHECK(value->Get<int>() == DevelAnimatedGradientVisual::SpreadType::REFLECT);
1759
1760       // If loop_count = 0, Animation doesn't created.
1761       // Optimized resultMap only have one value, which is target value
1762       // Note: target value will be changed by direction option.
1763       value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_POSITION, Property::VECTOR2);
1764       DALI_TEST_CHECK(value);
1765       DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? start1 : start2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1766
1767       value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_POSITION, Property::VECTOR2);
1768       DALI_TEST_CHECK(value);
1769       DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? end1 : end2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1770
1771       value = resultMap.Find(DevelAnimatedGradientVisual::Property::START_COLOR, Property::VECTOR4);
1772       DALI_TEST_CHECK(value);
1773       DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? start_color1 : start_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1774
1775       value = resultMap.Find(DevelAnimatedGradientVisual::Property::END_COLOR, Property::VECTOR4);
1776       DALI_TEST_CHECK(value);
1777       DALI_TEST_EQUALS(value->Get<Vector4>(), direction ? end_color1 : end_color2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1778
1779       value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, Property::VECTOR2);
1780       DALI_TEST_CHECK(value);
1781       DALI_TEST_EQUALS(value->Get<Vector2>(), direction ? rotate_center1 : rotate_center2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1782
1783       value = resultMap.Find(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, Property::FLOAT);
1784       DALI_TEST_CHECK(value);
1785       DALI_TEST_EQUALS(value->Get<float>(), direction ? rotate_amount1 : rotate_amount2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1786
1787       value = resultMap.Find(DevelAnimatedGradientVisual::Property::OFFSET, Property::FLOAT);
1788       DALI_TEST_CHECK(value);
1789       DALI_TEST_EQUALS(value->Get<float>(), direction ? offset1 : offset2, Math::MACHINE_EPSILON_100, TEST_LOCATION);
1790     }
1791   }
1792
1793   END_TEST;
1794 }
1795
1796 int UtcDaliVisualAnimateBorderVisual01(void)
1797 {
1798   ToolkitTestApplication application;
1799   tet_infoline("UtcDaliAnimateBorderVisual Color");
1800
1801   static std::vector<UniformData> customUniforms =
1802     {
1803       UniformData("borderColor", Property::Type::VECTOR4),
1804       UniformData("mixColor", Property::Type::VECTOR3),
1805     };
1806
1807   TestGraphicsController& graphics = application.GetGraphicsController();
1808   graphics.AddCustomUniforms(customUniforms);
1809
1810   VisualFactory factory = VisualFactory::Get();
1811   Property::Map propertyMap;
1812   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1813   propertyMap.Insert(Visual::Property::MIX_COLOR, Vector4(1, 1, 1, 0.8f));
1814   propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1815   propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1816   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1817
1818   Property::Map map;
1819   map["target"]      = "testVisual";
1820   map["property"]    = "mixColor";
1821   map["targetValue"] = Vector4(1, 1, 1, 0.1);
1822   map["animator"]    = Property::Map()
1823                       .Add("alphaFunction", "LINEAR")
1824                       .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
1825
1826   Dali::Toolkit::TransitionData transition = TransitionData::New(map);
1827
1828   DummyControl        actor     = DummyControl::New(true);
1829   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1830   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1831   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1832   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1833   application.GetScene().Add(actor);
1834
1835   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1836
1837   Renderer        renderer         = actor.GetRendererAt(0);
1838   Property::Index borderColorIndex = renderer.GetPropertyIndex(BorderVisual::Property::COLOR);
1839   Property::Index mixColorIndex    = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( Visual::Property::MIX_COLOR );
1840
1841   Animation animation = dummyImpl.CreateTransition(transition);
1842
1843   // Animate the mix color through the transition, and the border color through
1844   // programmatic method.
1845   animation.AnimateTo(Property(renderer, borderColorIndex), Color::WHITE);
1846   animation.Play();
1847
1848   application.SendNotification();
1849   application.Render(0);
1850   application.Render(2000u); // halfway point between blue and white
1851
1852   Vector4 color     = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1853   Vector4 testColor = (Color::BLUE + Color::WHITE) * 0.5f;
1854   DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1855   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", testColor), true, TEST_LOCATION);
1856
1857   color     = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1858   testColor = Vector4(1, 1, 1, 0.45f);
1859   DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), 0.0001f, TEST_LOCATION);
1860   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1861
1862   Vector4 uColor;
1863   DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1864   DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1865
1866   application.Render(2000u);
1867
1868   color = renderer.GetCurrentProperty<Vector4>(borderColorIndex);
1869   DALI_TEST_EQUALS(color, Color::WHITE, TEST_LOCATION);
1870   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("borderColor", Color::WHITE), true, TEST_LOCATION);
1871
1872   color     = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1873   testColor = Vector4(1, 1, 1, 0.1);
1874   DALI_TEST_EQUALS(Vector3(color), Vector3(testColor), TEST_LOCATION);
1875   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(testColor)), true, TEST_LOCATION);
1876
1877   DALI_TEST_CHECK(application.GetGlAbstraction().GetUniformValue<Vector4>("uColor", uColor));
1878   DALI_TEST_EQUALS(uColor.a, testColor.a, TEST_LOCATION);
1879
1880   END_TEST;
1881 }
1882
1883 int UtcDaliVisualAnimateBorderVisual02(void)
1884 {
1885   ToolkitTestApplication application;
1886   tet_infoline("UtcDaliAnimateBorderVisual Size");
1887
1888   static std::vector<UniformData> customUniforms =
1889     {
1890       UniformData("borderSize", Property::Type::FLOAT),
1891     };
1892
1893   TestGraphicsController& graphics = application.GetGraphicsController();
1894   graphics.AddCustomUniforms(customUniforms);
1895
1896   VisualFactory factory = VisualFactory::Get();
1897   Property::Map propertyMap;
1898   propertyMap.Insert(Visual::Property::TYPE, Visual::BORDER);
1899   propertyMap.Insert(BorderVisual::Property::COLOR, Color::BLUE);
1900   propertyMap.Insert(BorderVisual::Property::SIZE, 5.f);
1901   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1902
1903   DummyControl        actor     = DummyControl::New(true);
1904   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1905   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1906   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1907   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1908   application.GetScene().Add(actor);
1909
1910   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1911
1912   Renderer        renderer = actor.GetRendererAt(0);
1913   Property::Index index    = renderer.GetPropertyIndex(BorderVisual::Property::SIZE);
1914
1915   Animation animation = Animation::New(4.0f);
1916   animation.AnimateTo(Property(renderer, index), 9.0f);
1917   animation.Play();
1918
1919   application.SendNotification();
1920   application.Render(0);
1921   application.Render(2000u); // halfway point
1922
1923   float size = renderer.GetCurrentProperty<float>(index);
1924   DALI_TEST_EQUALS(size, 7.0f, 0.0001f, TEST_LOCATION);
1925   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 7.0f), true, TEST_LOCATION);
1926
1927   application.Render(2000u); // halfway point between blue and white
1928
1929   size = renderer.GetCurrentProperty<float>(index);
1930   DALI_TEST_EQUALS(size, 9.0f, 0.0001f, TEST_LOCATION);
1931   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("borderSize", 9.0f), true, TEST_LOCATION);
1932
1933   END_TEST;
1934 }
1935
1936 int UtcDaliVisualAnimateColorVisual(void)
1937 {
1938   ToolkitTestApplication application;
1939   tet_infoline("UtcDaliAnimateColorVisual mixColor");
1940
1941   static std::vector<UniformData> customUniforms =
1942     {
1943       UniformData("mixColor", Property::Type::VECTOR3),
1944     };
1945
1946   TestGraphicsController& graphics = application.GetGraphicsController();
1947   graphics.AddCustomUniforms(customUniforms);
1948
1949   VisualFactory factory = VisualFactory::Get();
1950   Property::Map propertyMap;
1951   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
1952   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
1953   Visual::Base borderVisual = factory.CreateVisual(propertyMap);
1954
1955   DummyControl        actor     = DummyControl::New(true);
1956   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
1957   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, borderVisual);
1958   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
1959   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
1960   application.GetScene().Add(actor);
1961
1962   DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
1963
1964   Renderer        renderer      = actor.GetRendererAt(0);
1965   Property::Index mixColorIndex = VisualRenderer::Property::VISUAL_MIX_COLOR; //renderer.GetPropertyIndex( ColorVisual::Property::MIX_COLOR );
1966
1967   Property::Value blendModeValue = renderer.GetProperty(Renderer::Property::BLEND_MODE);
1968   DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1969
1970   Animation animation = Animation::New(4.0f);
1971   animation.AnimateTo(Property(renderer, mixColorIndex), Vector3(Color::WHITE));
1972   animation.Play();
1973
1974   application.SendNotification();
1975   application.Render(0);
1976   application.Render(2000u); // halfway point
1977
1978   Vector3 color     = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1979   Vector3 testColor = Vector3(Color::BLUE + Color::WHITE) * 0.5f;
1980   DALI_TEST_EQUALS(color, testColor, TEST_LOCATION);
1981
1982   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", testColor), true, TEST_LOCATION);
1983
1984   application.Render(2000u); // halfway point between blue and white
1985
1986   color = renderer.GetCurrentProperty<Vector3>(mixColorIndex);
1987   DALI_TEST_EQUALS(color, Vector3(Color::WHITE), TEST_LOCATION);
1988
1989   DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(Color::WHITE)), true, TEST_LOCATION);
1990
1991   blendModeValue = renderer.GetCurrentProperty(Renderer::Property::BLEND_MODE);
1992   DALI_TEST_EQUALS(blendModeValue.Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
1993
1994   END_TEST;
1995 }
1996
1997 int UtcDaliVisualAnimatePrimitiveVisual(void)
1998 {
1999   ToolkitTestApplication application;
2000   tet_infoline("UtcDaliAnimatePrimitiveVisual color");
2001
2002   static std::vector<UniformData> customUniforms =
2003     {
2004       UniformData("mixColor", Property::Type::VECTOR3),
2005     };
2006
2007   TestGraphicsController& graphics = application.GetGraphicsController();
2008   graphics.AddCustomUniforms(customUniforms);
2009
2010   {
2011     VisualFactory factory = VisualFactory::Get();
2012     Property::Map propertyMap;
2013     propertyMap.Insert(Visual::Property::TYPE, Visual::PRIMITIVE);
2014     propertyMap.Insert(PrimitiveVisual::Property::SHAPE, PrimitiveVisual::Shape::CUBE);
2015     propertyMap.Insert(PrimitiveVisual::Property::MIX_COLOR, Color::BLUE);
2016     Visual::Base visual = factory.CreateVisual(propertyMap);
2017
2018     DummyControl        actor     = DummyControl::New(true);
2019     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2020     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2021     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2022     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2023     actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2024     application.GetScene().Add(actor);
2025
2026     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2027
2028     Renderer renderer = actor.GetRendererAt(0);
2029
2030     const Vector4 INITIAL_MIX_COLOR(1.0f, 0.0f, 1.0f, 0.5f); // Magenta with half alpha
2031     const Vector4 TARGET_MIX_COLOR(Color::RED);
2032
2033     Property::Map map;
2034     map["target"]       = "testVisual";
2035     map["property"]     = "mixColor";
2036     map["initialValue"] = INITIAL_MIX_COLOR;
2037     map["targetValue"]  = TARGET_MIX_COLOR;
2038     map["animator"]     = Property::Map()
2039                         .Add("alphaFunction", "LINEAR")
2040                         .Add("timePeriod", Property::Map().Add("delay", 0.0f).Add("duration", 4.0f));
2041
2042     Dali::Toolkit::TransitionData transition = TransitionData::New(map);
2043
2044     Animation animation = dummyImpl.CreateTransition(transition);
2045     animation.AnimateTo(Property(actor, Actor::Property::COLOR), Color::WHITE);
2046     animation.Play();
2047
2048     TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2049     glAbstraction.EnableEnableDisableCallTrace(true);
2050     TraceCallStack&    glEnableStack = glAbstraction.GetEnableDisableTrace();
2051     std::ostringstream blendStr;
2052     blendStr << std::hex << GL_BLEND;
2053
2054     application.SendNotification();
2055     application.Render(0);
2056     application.Render(2000u); // halfway point
2057     application.SendNotification();
2058
2059     Vector4 halfwayColor = (INITIAL_MIX_COLOR + TARGET_MIX_COLOR) * 0.5;
2060     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(0.5f, 0.5f, 0.5f, halfwayColor.a)), true, TEST_LOCATION);
2061     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(halfwayColor)), true, TEST_LOCATION);
2062
2063     DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str()));
2064
2065     glEnableStack.Reset();
2066
2067     application.Render(2001u);      // go past end
2068     application.SendNotification(); // Trigger signals
2069
2070     DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
2071     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("uColor", Vector4(1.0f, 1.0f, 1.0f, TARGET_MIX_COLOR.a)), true, TEST_LOCATION);
2072     DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector3>("mixColor", Vector3(TARGET_MIX_COLOR)), true, TEST_LOCATION);
2073
2074     DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", blendStr.str()));
2075
2076     actor.Unparent();
2077   }
2078
2079   END_TEST;
2080 }
2081
2082 int UtcDaliVisualAnimatedGradientVisual01(void)
2083 {
2084   ToolkitTestApplication application;
2085   tet_infoline("UtcDaliAnimatedGradientVisual with default");
2086
2087   static std::vector<UniformData> customUniforms =
2088     {
2089       UniformData("start_point", Property::Type::VECTOR2),
2090       UniformData("end_point", Property::Type::VECTOR2),
2091       UniformData("start_color", Property::Type::VECTOR4),
2092       UniformData("end_color", Property::Type::VECTOR4),
2093       UniformData("rotate_center", Property::Type::VECTOR2),
2094       UniformData("rotate_angle", Property::Type::FLOAT),
2095       UniformData("gradient_offset", Property::Type::FLOAT),
2096     };
2097
2098   TestGraphicsController& graphics = application.GetGraphicsController();
2099   graphics.AddCustomUniforms(customUniforms);
2100
2101   {
2102     VisualFactory factory = VisualFactory::Get();
2103     Property::Map propertyMap;
2104     propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2105     Visual::Base visual = factory.CreateVisual(propertyMap);
2106
2107     DummyControl        actor     = DummyControl::New(true);
2108     Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2109     dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2110     actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2111     actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2112     actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2113     application.GetScene().Add(actor);
2114
2115     application.SendNotification();
2116     application.Render(0);
2117     application.SendNotification();
2118
2119     DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2120
2121     for(int step_iter = 0; step_iter < 3; step_iter++)
2122     {
2123       application.SendNotification();
2124       application.Render(0);
2125       application.Render(750u); // step i/4
2126       application.SendNotification();
2127
2128       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("start_point", Vector2(-0.5f, 0.0f)), true, TEST_LOCATION);
2129       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("end_point", Vector2(0.5f, 0.0f)), true, TEST_LOCATION);
2130       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("start_color", Vector4(143.0f, 170.0f, 220.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2131       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector4>("end_color", Vector4(255.0f, 163.0f, 163.0f, 255.0f) / 255.0f), true, TEST_LOCATION);
2132       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<Vector2>("rotate_center", Vector2(0.0f, 0.0f)), true, TEST_LOCATION);
2133       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("rotate_angle", 0.0f), true, TEST_LOCATION);
2134       DALI_TEST_EQUALS(application.GetGlAbstraction().CheckUniformValue<float>("gradient_offset", 0.5f * step_iter + 0.5f), true, TEST_LOCATION);
2135     }
2136
2137     //Not check here. cause gradient_offset value can be 2.0f or 0.0f
2138     application.Render(750u); // go to end
2139     application.SendNotification();
2140
2141     application.Render(10u); // finish
2142     application.SendNotification();
2143
2144     actor.Unparent();
2145     application.SendNotification();
2146     application.Render(0u);
2147     application.SendNotification();
2148   }
2149
2150   END_TEST;
2151 }
2152
2153 int UtcDaliVisualAnimatedGradientVisual02(void)
2154 {
2155   ToolkitTestApplication application;
2156   tet_infoline("UtcDaliAnimatedGradientVisual with full-option");
2157
2158   static std::vector<UniformData> customUniforms =
2159     {
2160       UniformData("start_point", Property::Type::VECTOR2),
2161       UniformData("end_point", Property::Type::VECTOR2),
2162       UniformData("start_color", Property::Type::VECTOR4),
2163       UniformData("end_color", Property::Type::VECTOR4),
2164       UniformData("rotate_center", Property::Type::VECTOR2),
2165       UniformData("rotate_angle", Property::Type::FLOAT),
2166       UniformData("gradient_offset", Property::Type::FLOAT),
2167     };
2168
2169   TestGraphicsController& graphics = application.GetGraphicsController();
2170   graphics.AddCustomUniforms(customUniforms);
2171
2172   {
2173     float _delay[4]      = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2174     int   _direction[2]  = {0, 1};
2175     int   _loop_count[3] = {-1, 0, 1};
2176     int   _motion[2]     = {0, 1};
2177     int   _easing[4]     = {0, 1, 2, 3};
2178
2179     int test_case_max = 4 * 2 * 3 * 2 * 4;
2180     int test_case     = 0;
2181     int test_case_d   = 7; // 7 is the number of animated properties.
2182
2183     float _duration     = 0.4f;
2184     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2185     float noise_maker   = 0.0f;
2186     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2187     for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2188     {
2189       tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2190
2191       VisualFactory factory = VisualFactory::Get();
2192       Property::Map propertyMap;
2193       Property::Map animationMap;
2194       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2195
2196       int gradient_type = DevelAnimatedGradientVisual::GradientType::LINEAR;
2197       int unit_type     = DevelAnimatedGradientVisual::UnitType::USER_SPACE;
2198       int spread_type   = DevelAnimatedGradientVisual::SpreadType::REPEAT;
2199
2200       auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value& start, const Property::Value& target, int tc_offset) -> Property::Map& {
2201         int tc         = (test_case + tc_offset);
2202         int idx_easing = tc % 4;
2203         tc /= 4;
2204         int idx_motion = tc % 2;
2205         tc /= 2;
2206         int idx_loop_count = tc % 3;
2207         tc /= 3;
2208         int idx_direction = tc % 2;
2209         tc /= 2;
2210         int idx_delay = tc % 4;
2211         tc /= 4;
2212
2213         float duration     = _duration - _repeat_delay;
2214         float repeat_delay = _repeat_delay;
2215         float delay        = _delay[idx_delay] * _duration;
2216         int   direction    = _direction[idx_direction];
2217         int   loop_count   = _loop_count[idx_loop_count];
2218         int   motion       = _motion[idx_motion];
2219         int   easing       = _easing[idx_easing];
2220
2221         animationMap.Clear();
2222         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::START, start);
2223         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::TARGET, target);
2224         if(direction == 0)
2225         {
2226           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::FORWARD);
2227         }
2228         else
2229         {
2230           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DIRECTION, DevelAnimatedGradientVisual::AnimationParameter::DirectionType::BACKWARD);
2231         }
2232         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DURATION, duration);
2233         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::DELAY, delay);
2234         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT, loop_count);
2235         animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::REPEAT_DELAY, repeat_delay);
2236         if(motion == 0)
2237         {
2238           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::LOOP);
2239         }
2240         else
2241         {
2242           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::MOTION_TYPE, DevelAnimatedGradientVisual::AnimationParameter::MotionType::MIRROR);
2243         }
2244         if(easing == 0)
2245         {
2246           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::LINEAR);
2247         }
2248         else if(easing == 1)
2249         {
2250           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN);
2251         }
2252         else if(easing == 2)
2253         {
2254           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::OUT);
2255         }
2256         else
2257         {
2258           animationMap.Insert(DevelAnimatedGradientVisual::AnimationParameter::Property::EASING_TYPE, DevelAnimatedGradientVisual::AnimationParameter::EasingType::IN_OUT);
2259         }
2260
2261         return animationMap;
2262       };
2263
2264       // Give different values for debuging
2265       noise_maker += 1.0f;
2266       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2267       Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2268       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2269       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2270       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2271       float   rotate_amount1 = 0.0f + noise_maker * 0.1f;
2272       float   offset1        = 0.f + noise_maker * 0.1f;
2273
2274       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2275       Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2276       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2277       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2278       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2279       float   rotate_amount2 = 7.0f + noise_maker * 0.1f;
2280       float   offset2        = 2.f + noise_maker * 0.1f;
2281
2282       propertyMap.Insert(DevelAnimatedGradientVisual::Property::GRADIENT_TYPE, gradient_type);
2283       propertyMap.Insert(DevelAnimatedGradientVisual::Property::UNIT_TYPE, unit_type);
2284       propertyMap.Insert(DevelAnimatedGradientVisual::Property::SPREAD_TYPE, spread_type);
2285
2286       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_POSITION, buildAnimatedMap(start1, start2, 0));
2287       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_POSITION, buildAnimatedMap(end1, end2, 1));
2288       propertyMap.Insert(DevelAnimatedGradientVisual::Property::START_COLOR, buildAnimatedMap(start_color1, start_color2, 2));
2289       propertyMap.Insert(DevelAnimatedGradientVisual::Property::END_COLOR, buildAnimatedMap(end_color1, end_color2, 3));
2290       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_CENTER, buildAnimatedMap(rotate_center1, rotate_center2, 4));
2291       propertyMap.Insert(DevelAnimatedGradientVisual::Property::ROTATE_AMOUNT, buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2292       propertyMap.Insert(DevelAnimatedGradientVisual::Property::OFFSET, buildAnimatedMap(offset1, offset2, 6));
2293
2294       Visual::Base visual = factory.CreateVisual(propertyMap);
2295
2296       DummyControl        actor     = DummyControl::New(true);
2297       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2298       dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2299       actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2300       actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2301       actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2302       application.GetScene().Add(actor);
2303
2304       application.SendNotification();
2305       application.Render(0);
2306       application.SendNotification();
2307
2308       DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2309
2310       application.SendNotification();
2311
2312       //Compare between CPU calculated value and Shader Visual calculated value
2313       auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress) -> void {
2314         int tc         = (test_case + tc_offset);
2315         int idx_easing = tc % 4;
2316         tc /= 4;
2317         int idx_motion = tc % 2;
2318         tc /= 2;
2319         int idx_loop_count = tc % 3;
2320         tc /= 3;
2321         int idx_direction = tc % 2;
2322         tc /= 2;
2323         int idx_delay = tc % 4;
2324         tc /= 4;
2325
2326         float duration     = _duration - _repeat_delay;
2327         float repeat_delay = _repeat_delay;
2328         float delay        = _delay[idx_delay] * _duration;
2329         int   direction    = _direction[idx_direction];
2330         int   loop_count   = _loop_count[idx_loop_count];
2331         int   motion       = _motion[idx_motion];
2332         int   easing       = _easing[idx_easing];
2333
2334         progress -= delay / _duration;
2335
2336         Property::Value s = start;
2337         Property::Value t = target;
2338         if(direction == 1)
2339         {
2340           s = target;
2341           t = start;
2342         }
2343         float x; ///< Animator progress value
2344         if(loop_count == 0)
2345         {
2346           x = 1.0f;
2347         }
2348         else if(loop_count > 0 && progress + 0.01f > loop_count)
2349         {
2350           x = (motion == 0) ? 1.0f : 0.0f;
2351         }
2352         else
2353         {
2354           if(progress < 0.0f)
2355           {
2356             progress = 0.0f;
2357           }
2358           progress = fmodf(progress, 1.0f);
2359           progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2360
2361           x = progress;
2362           if(motion == 1)
2363           {
2364             x = progress * 2.0f;
2365             if(x > 1.0f)
2366             {
2367               x = 2.0f - x;
2368             }
2369           }
2370
2371           if(easing == 1) // EASE_IN
2372           {
2373             x = x * x;
2374           }
2375           else if(easing == 2) // EASE_OUT
2376           {
2377             x = 2.0f * x - x * x;
2378           }
2379           else if(easing == 3) // EASE_IN_OUT
2380           {
2381             x = x * x * (3.0f - 2.0f * x);
2382           }
2383         }
2384         if(value_type == 0) // result type is Float
2385         {
2386           float res;
2387           float cur;
2388           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2389           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2390           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2391         }
2392         else if(value_type == 1) // result type is Vector2
2393         {
2394           Vector2 res;
2395           Vector2 cur;
2396           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2397           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2398           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2399         }
2400         else if(value_type == 2) // result type is Vector3
2401         {
2402           Vector3 res;
2403           Vector3 cur;
2404           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2405           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2406           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2407         }
2408         else // result type is Vector4
2409         {
2410           Vector4 res;
2411           Vector4 cur;
2412           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2413           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2414           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2415         }
2416       };
2417
2418       float step = 0.0f;
2419       for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2420       {
2421         for(int step_iter = 0; step_iter < 3; step_iter++)
2422         {
2423           application.SendNotification();
2424           application.Render(_duration * 250.f); // step i/4
2425           application.SendNotification();
2426           step += 0.25f;
2427
2428           testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2429           testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2430           testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2431           testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2432           testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2433           testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2434           testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2435         }
2436         application.SendNotification();
2437         application.Render(_duration * 250.f); // step 4/4 will not test
2438         application.SendNotification();
2439         step += 0.25f;
2440       }
2441
2442       application.SendNotification();
2443       actor.Unparent();
2444       application.SendNotification();
2445       application.Render(10.f); // tempral time
2446       application.SendNotification();
2447     }
2448   }
2449
2450   END_TEST;
2451 }
2452
2453 int UtcDaliVisualAnimatedGradientVisual03(void)
2454 {
2455   ToolkitTestApplication application;
2456   tet_infoline("UtcDaliAnimatedGradientVisual with full-option use string key");
2457
2458   static std::vector<UniformData> customUniforms =
2459     {
2460       UniformData("start_point", Property::Type::VECTOR2),
2461       UniformData("end_point", Property::Type::VECTOR2),
2462       UniformData("start_color", Property::Type::VECTOR4),
2463       UniformData("end_color", Property::Type::VECTOR4),
2464       UniformData("rotate_center", Property::Type::VECTOR2),
2465       UniformData("rotate_angle", Property::Type::FLOAT),
2466       UniformData("gradient_offset", Property::Type::FLOAT),
2467     };
2468
2469   TestGraphicsController& graphics = application.GetGraphicsController();
2470   graphics.AddCustomUniforms(customUniforms);
2471
2472   {
2473     float _delay[4]      = {0.0f, -1.35f, 0.15f, -0.4f}; // fract(_delay) must NOT be 1/4, 2/4, 3/4. cause we don't know progress is 1.0f or 0.0f
2474     int   _direction[2]  = {0, 1};
2475     int   _loop_count[3] = {-1, 0, 1};
2476     int   _motion[2]     = {0, 1};
2477     int   _easing[4]     = {0, 1, 2, 3};
2478
2479     int test_case_max = 4 * 2 * 3 * 2 * 4;
2480     int test_case     = 0;
2481     int test_case_d   = 7; // 7 is the number of animated properties.
2482
2483     float _duration     = 0.4f;
2484     float _repeat_delay = _duration * 0.25f; // < _duration. cause real_duration = _duration - _repeat_delay;
2485     float noise_maker   = 0.2f;
2486     // total testing time = ceil((4*2*3*2*4) / 7) * (_duration(=0.4) * 2 + 0.01) = 22.68 seconds
2487     for(test_case = 0; test_case < test_case_max + test_case_d; test_case += test_case_d)
2488     {
2489       tet_printf("test [%d ~ %d / %d]\n", test_case, test_case + test_case_d - 1, test_case_max);
2490
2491       VisualFactory factory = VisualFactory::Get();
2492       Property::Map propertyMap;
2493       Property::Map animationMap;
2494       propertyMap.Insert(Visual::Property::TYPE, DevelVisual::ANIMATED_GRADIENT);
2495
2496       auto buildAnimatedMap = [&animationMap, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const Property::Value& start, const Property::Value& target, int tc_offset) -> Property::Map& {
2497         int tc         = (test_case + tc_offset);
2498         int idx_easing = tc % 4;
2499         tc /= 4;
2500         int idx_motion = tc % 2;
2501         tc /= 2;
2502         int idx_loop_count = tc % 3;
2503         tc /= 3;
2504         int idx_direction = tc % 2;
2505         tc /= 2;
2506         int idx_delay = tc % 4;
2507         tc /= 4;
2508
2509         float duration     = _duration - _repeat_delay;
2510         float repeat_delay = _repeat_delay;
2511         float delay        = _delay[idx_delay] * _duration;
2512         int   direction    = _direction[idx_direction];
2513         int   loop_count   = _loop_count[idx_loop_count];
2514         int   motion       = _motion[idx_motion];
2515         int   easing       = _easing[idx_easing];
2516
2517         animationMap.Clear();
2518         animationMap.Insert("startValue", start);
2519         animationMap.Insert("targetValue", target);
2520         if(direction == 0)
2521         {
2522           animationMap.Insert("directionType", "FORWARD");
2523         }
2524         else
2525         {
2526           animationMap.Insert("directionType", "BACKWARD");
2527         }
2528         animationMap.Insert("duration", duration);
2529         animationMap.Insert("delay", delay);
2530         animationMap.Insert("repeat", loop_count);
2531         animationMap.Insert("repeatDelay", repeat_delay);
2532         if(motion == 0)
2533         {
2534           animationMap.Insert("motionType", "LOOP");
2535         }
2536         else
2537         {
2538           animationMap.Insert("motionType", "MIRROR");
2539         }
2540         if(easing == 0)
2541         {
2542           animationMap.Insert("easingType", "LINEAR");
2543         }
2544         else if(easing == 1)
2545         {
2546           animationMap.Insert("easingType", "IN");
2547         }
2548         else if(easing == 2)
2549         {
2550           animationMap.Insert("easingType", "OUT");
2551         }
2552         else
2553         {
2554           animationMap.Insert("easingType", "IN_OUT");
2555         }
2556
2557         return animationMap;
2558       };
2559
2560       // Give different values for debuging
2561       noise_maker += 0.8f;
2562       Vector2 start1(-0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2563       Vector2 end1(0.5f + noise_maker * 0.1f, -0.5f + noise_maker * 0.1f);
2564       Vector4 start_color1(1.0f, 0.7f, 0.5f, 1.0f);
2565       Vector4 end_color1(0.7f, 0.5f, 1.0f, 1.0f);
2566       Vector2 rotate_center1(0.0f + noise_maker * 0.1f, 0.4f + noise_maker * 0.1f);
2567       float   rotate_amount1 = 0.0f + noise_maker * 0.1f;
2568       float   offset1        = 0.f + noise_maker * 0.1f;
2569
2570       Vector2 start2(0.2f + noise_maker * 0.1f, -0.7f + noise_maker * 0.1f);
2571       Vector2 end2(0.5f + noise_maker * 0.1f, 0.5f + noise_maker * 0.1f);
2572       Vector4 start_color2(0.0f, 0.1f, 0.8f, 1.0f);
2573       Vector4 end_color2(0.3f, 1.0f, 0.1f, 0.0f);
2574       Vector2 rotate_center2(0.0f + noise_maker * 0.1f, -0.4f + noise_maker * 0.1f);
2575       float   rotate_amount2 = 7.0f + noise_maker * 0.1f;
2576       float   offset2        = 2.f + noise_maker * 0.1f;
2577
2578       propertyMap.Insert("gradientType", "LINEAR");
2579       propertyMap.Insert("unitType", "USER_SPACE");
2580       propertyMap.Insert("spreadType", "CLAMP");
2581
2582       propertyMap.Insert("startPosition", buildAnimatedMap(start1, start2, 0));
2583       propertyMap.Insert("endPosition", buildAnimatedMap(end1, end2, 1));
2584       propertyMap.Insert("startColor", buildAnimatedMap(start_color1, start_color2, 2));
2585       propertyMap.Insert("endColor", buildAnimatedMap(end_color1, end_color2, 3));
2586       propertyMap.Insert("rotateCenter", buildAnimatedMap(rotate_center1, rotate_center2, 4));
2587       propertyMap.Insert("rotateAmount", buildAnimatedMap(rotate_amount1, rotate_amount2, 5));
2588       propertyMap.Insert("offset", buildAnimatedMap(offset1, offset2, 6));
2589
2590       Visual::Base visual = factory.CreateVisual(propertyMap);
2591
2592       DummyControl        actor     = DummyControl::New(true);
2593       Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2594       dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2595       actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2596       actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2597       actor.SetProperty(Actor::Property::COLOR, Color::BLACK);
2598       application.GetScene().Add(actor);
2599
2600       application.SendNotification();
2601       application.Render(0);
2602       application.SendNotification();
2603
2604       DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
2605
2606       application.SendNotification();
2607
2608       //Compare between CPU calculated value and Shader Visual calculated value
2609       auto testProperty = [&application, &_direction, &_duration, &_delay, &_loop_count, &_repeat_delay, &_motion, &_easing, &test_case](const char* name, const Property::Value& start, const Property::Value& target, int tc_offset, int value_type, float progress) -> void {
2610         int tc         = (test_case + tc_offset);
2611         int idx_easing = tc % 4;
2612         tc /= 4;
2613         int idx_motion = tc % 2;
2614         tc /= 2;
2615         int idx_loop_count = tc % 3;
2616         tc /= 3;
2617         int idx_direction = tc % 2;
2618         tc /= 2;
2619         int idx_delay = tc % 4;
2620         tc /= 4;
2621
2622         float duration     = _duration - _repeat_delay;
2623         float repeat_delay = _repeat_delay;
2624         float delay        = _delay[idx_delay] * _duration;
2625         int   direction    = _direction[idx_direction];
2626         int   loop_count   = _loop_count[idx_loop_count];
2627         int   motion       = _motion[idx_motion];
2628         int   easing       = _easing[idx_easing];
2629
2630         progress -= delay / _duration;
2631
2632         Property::Value s = start;
2633         Property::Value t = target;
2634         if(direction == 1)
2635         {
2636           s = target;
2637           t = start;
2638         }
2639         float x; ///< Animator progress value
2640         if(loop_count == 0)
2641         {
2642           x = 1.0f;
2643         }
2644         else if(loop_count > 0 && progress + 0.01f > loop_count)
2645         {
2646           x = (motion == 0) ? 1.0f : 0.0f;
2647         }
2648         else
2649         {
2650           if(progress < 0.0f)
2651           {
2652             progress = 0.0f;
2653           }
2654           progress = fmodf(progress, 1.0f);
2655           progress = Dali::Clamp((progress * (duration + repeat_delay) - repeat_delay) / duration, 0.0f, 1.0f);
2656
2657           x = progress;
2658           if(motion == 1)
2659           {
2660             x = progress * 2.0f;
2661             if(x > 1.0f)
2662             {
2663               x = 2.0f - x;
2664             }
2665           }
2666
2667           if(easing == 1) // EASE_IN
2668           {
2669             x = x * x;
2670           }
2671           else if(easing == 2) // EASE_OUT
2672           {
2673             x = 2.0f * x - x * x;
2674           }
2675           else if(easing == 3) // EASE_IN_OUT
2676           {
2677             x = x * x * (3.0f - 2.0f * x);
2678           }
2679         }
2680         if(value_type == 0) // result type is Float
2681         {
2682           float res;
2683           float cur;
2684           res = s.Get<float>() * (1.0f - x) + t.Get<float>() * (x);
2685           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<float>(name, cur), true, TEST_LOCATION);
2686           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2687         }
2688         else if(value_type == 1) // result type is Vector2
2689         {
2690           Vector2 res;
2691           Vector2 cur;
2692           res = s.Get<Vector2>() * (1.0f - x) + t.Get<Vector2>() * (x);
2693           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector2>(name, cur), true, TEST_LOCATION);
2694           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2695         }
2696         else if(value_type == 2) // result type is Vector3
2697         {
2698           Vector3 res;
2699           Vector3 cur;
2700           res = s.Get<Vector3>() * (1.0f - x) + t.Get<Vector3>() * (x);
2701           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector3>(name, cur), true, TEST_LOCATION);
2702           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2703         }
2704         else // result type is Vector4
2705         {
2706           Vector4 res;
2707           Vector4 cur;
2708           res = s.Get<Vector4>() * (1.0f - x) + t.Get<Vector4>() * (x);
2709           DALI_TEST_EQUALS(application.GetGlAbstraction().GetUniformValue<Vector4>(name, cur), true, TEST_LOCATION);
2710           DALI_TEST_EQUALS(res, cur, Math::MACHINE_EPSILON_100, TEST_LOCATION);
2711         }
2712       };
2713
2714       float step = 0.0f;
2715       for(int iter = 0; iter < 2; iter++) // test 2*duration seconds
2716       {
2717         for(int step_iter = 0; step_iter < 3; step_iter++)
2718         {
2719           application.SendNotification();
2720           application.Render(_duration * 250.f); // step i/4
2721           application.SendNotification();
2722           step += 0.25f;
2723
2724           testProperty("start_point", Property::Value(start1), Property::Value(start2), 0, 1, step);
2725           testProperty("end_point", Property::Value(end1), Property::Value(end2), 1, 1, step);
2726           testProperty("start_color", Property::Value(start_color1), Property::Value(start_color2), 2, 3, step);
2727           testProperty("end_color", Property::Value(end_color1), Property::Value(end_color2), 3, 3, step);
2728           testProperty("rotate_center", Property::Value(rotate_center1), Property::Value(rotate_center2), 4, 1, step);
2729           testProperty("rotate_angle", Property::Value(rotate_amount1), Property::Value(rotate_amount2), 5, 0, step);
2730           testProperty("gradient_offset", Property::Value(offset1), Property::Value(offset2), 6, 0, step);
2731         }
2732         application.SendNotification();
2733         application.Render(_duration * 250.f); // step 4/4 will not test
2734         application.SendNotification();
2735         step += 0.25f;
2736       }
2737
2738       application.SendNotification();
2739       actor.Unparent();
2740       application.SendNotification();
2741       application.Render(10.f); // tempral time
2742       application.SendNotification();
2743     }
2744   }
2745
2746   END_TEST;
2747 }
2748
2749 int UtcDaliVisualWireframeVisual(void)
2750 {
2751   ToolkitTestApplication application;
2752
2753   VisualFactory factory = VisualFactory::Get();
2754   Property::Map propertyMap;
2755   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::WIREFRAME);
2756
2757   // Create the visual.
2758   Visual::Base visual = factory.CreateVisual(propertyMap);
2759
2760   DALI_TEST_CHECK(visual);
2761
2762   Property::Map resultMap;
2763   visual.CreatePropertyMap(resultMap);
2764
2765   // Check the property values from the returned map from visual
2766   Property::Value* value = resultMap.Find(Toolkit::Visual::Property::TYPE, Property::INTEGER);
2767   DALI_TEST_CHECK(value);
2768   DALI_TEST_CHECK(value->Get<int>() == Visual::WIREFRAME);
2769
2770   END_TEST;
2771 }
2772
2773 int UtcDaliVisualGetTransform(void)
2774 {
2775   ToolkitTestApplication application;
2776   tet_infoline("UtcDaliVisualGetTransform: ColorVisual");
2777
2778   VisualFactory factory = VisualFactory::Get();
2779   Property::Map propertyMap;
2780   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2781   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2782   Visual::Base colorVisual = factory.CreateVisual(propertyMap);
2783
2784   Dali::Property::Map visualMap;
2785   colorVisual.CreatePropertyMap(visualMap);
2786   Property::Value*     value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2787   Dali::Property::Map* map   = value->GetMap();
2788   DALI_TEST_CHECK(map);
2789
2790   //Test default values
2791   {
2792     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2793     DALI_TEST_CHECK(typeValue);
2794     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2795   }
2796   {
2797     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2798     DALI_TEST_CHECK(typeValue);
2799     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(1.0f, 1.0f));
2800   }
2801   {
2802     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2803     DALI_TEST_CHECK(typeValue);
2804     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2805   }
2806   {
2807     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2808     DALI_TEST_CHECK(typeValue);
2809     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE));
2810   }
2811   {
2812     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2813     DALI_TEST_CHECK(typeValue);
2814     DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2815   }
2816   {
2817     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2818     DALI_TEST_CHECK(typeValue);
2819     DALI_TEST_CHECK((Toolkit::Align::Type)typeValue->Get<int>() == Toolkit::Align::TOP_BEGIN);
2820   }
2821   {
2822     Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2823     DALI_TEST_CHECK(typeValue);
2824     DALI_TEST_CHECK(typeValue->Get<Vector2>() == Vector2(0.0f, 0.0f));
2825   }
2826
2827   END_TEST;
2828 }
2829
2830 static void TestTransform(ToolkitTestApplication& application, Visual::Base visual)
2831 {
2832   Property::Map transform;
2833   transform.Insert(Visual::Transform::Property::OFFSET, Vector2(10.0f, 10.0f));
2834   transform.Insert(Visual::Transform::Property::SIZE, Vector2(0.2f, 0.2f));
2835   transform.Insert(Visual::Transform::Property::OFFSET_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2836   transform.Insert(Visual::Transform::Property::ORIGIN, "CENTER");
2837   transform.Insert(Visual::Transform::Property::ANCHOR_POINT, Toolkit::Align::BOTTOM_END);
2838   transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(50.0f, 50.0f));
2839
2840   visual.SetTransformAndSize(transform, Vector2(100, 100));
2841
2842   Dali::Property::Map visualMap;
2843   visual.CreatePropertyMap(visualMap);
2844   Property::Value*     value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
2845   Dali::Property::Map* map   = value->GetMap();
2846   DALI_TEST_CHECK(map);
2847
2848   {
2849     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET);
2850     DALI_TEST_CHECK(typeValue);
2851     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(10.0f, 10.0f), TEST_LOCATION);
2852   }
2853   {
2854     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE);
2855     DALI_TEST_CHECK(typeValue);
2856     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(0.2f, 0.2f), TEST_LOCATION);
2857   }
2858   {
2859     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
2860     DALI_TEST_CHECK(typeValue);
2861     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
2862   }
2863   {
2864     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
2865     DALI_TEST_CHECK(typeValue);
2866     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
2867   }
2868   {
2869     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ORIGIN);
2870     DALI_TEST_CHECK(typeValue);
2871     DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::CENTER, TEST_LOCATION);
2872   }
2873   {
2874     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::ANCHOR_POINT);
2875     DALI_TEST_CHECK(typeValue);
2876     DALI_TEST_EQUALS((Toolkit::Align::Type)typeValue->Get<int>(), Toolkit::Align::BOTTOM_END, TEST_LOCATION);
2877   }
2878   {
2879     Property::Value* typeValue = map->Find(Toolkit::DevelVisual::Transform::Property::EXTRA_SIZE);
2880     DALI_TEST_CHECK(typeValue);
2881     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(50.0f, 50.0f), TEST_LOCATION);
2882   }
2883
2884   //Put the visual on the stage
2885   DummyControl        actor     = DummyControl::New(true);
2886   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(actor.GetImplementation());
2887   actor.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
2888   actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
2889   application.GetScene().Add(actor);
2890
2891   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
2892   dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transform);
2893
2894   application.SendNotification();
2895   application.Render(0);
2896   Renderer renderer(actor.GetRendererAt(0));
2897
2898   Vector2 offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2899   DALI_TEST_EQUALS(offset, Vector2(10.0f, 10.0f), TEST_LOCATION);
2900
2901   Vector2 size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2902   DALI_TEST_EQUALS(size, Vector2(0.2f, 0.2f), TEST_LOCATION);
2903
2904   Vector4 offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2905   DALI_TEST_EQUALS(offsetSizeMode, Vector4(1.0f, 1.0f, 0.0f, 0.0f), TEST_LOCATION);
2906
2907   Vector2 parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2908   DALI_TEST_EQUALS(parentOrigin, Vector2(0.0f, 0.0f), TEST_LOCATION);
2909
2910   Vector2 anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2911   DALI_TEST_EQUALS(anchorPoint, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2912
2913   Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2914   DALI_TEST_EQUALS(extraSize, Vector2(50.0f, 50.0f), TEST_LOCATION);
2915
2916   //Set a new transform
2917   transform.Clear();
2918   transform = DefaultTransform();
2919   transform.Insert(Visual::Transform::Property::OFFSET, Vector2(20.0f, 20.0f));
2920   transform.Insert(Visual::Transform::Property::SIZE, Vector2(100.0f, 100.0f));
2921   transform.Insert(Visual::Transform::Property::SIZE_POLICY, Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::ABSOLUTE));
2922   transform.Insert(DevelVisual::Transform::Property::EXTRA_SIZE, Vector2(0.5f, 0.5f));
2923   visual.SetTransformAndSize(transform, Vector2(100, 100));
2924   application.SendNotification();
2925   application.Render(0);
2926
2927   //Check that the values have changed in the renderer
2928   offset = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_OFFSET);
2929   DALI_TEST_EQUALS(offset, Vector2(20.0f, 20.0f), TEST_LOCATION);
2930
2931   size = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_SIZE);
2932   DALI_TEST_EQUALS(size, Vector2(100.0f, 100.0f), TEST_LOCATION);
2933
2934   offsetSizeMode = renderer.GetProperty<Vector4>(VisualRenderer::Property::TRANSFORM_OFFSET_SIZE_MODE);
2935   DALI_TEST_EQUALS(offsetSizeMode, Vector4(0.0f, 0.0f, 1.0f, 1.0f), TEST_LOCATION);
2936
2937   //Parent origin and anchor point should have the default values
2938   parentOrigin = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ORIGIN);
2939   DALI_TEST_EQUALS(parentOrigin, Vector2(-0.5f, -0.5f), TEST_LOCATION);
2940
2941   anchorPoint = renderer.GetProperty<Vector2>(VisualRenderer::Property::TRANSFORM_ANCHOR_POINT);
2942   DALI_TEST_EQUALS(anchorPoint, Vector2(0.5f, 0.5f), TEST_LOCATION);
2943
2944   extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
2945   DALI_TEST_EQUALS(extraSize, Vector2(0.5f, 0.5f), TEST_LOCATION);
2946 }
2947
2948 int UtcDaliVisualSetTransform01(void)
2949 {
2950   ToolkitTestApplication application;
2951   tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2952
2953   VisualFactory factory = VisualFactory::Get();
2954   Property::Map propertyMap;
2955   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2956   propertyMap.Insert(Visual::Property::OPACITY, 0.5f);
2957   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2958   Visual::Base visual = factory.CreateVisual(propertyMap);
2959   TestTransform(application, visual);
2960   TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2961
2962   END_TEST;
2963 }
2964
2965 int UtcDaliVisualSetTransform0(void)
2966 {
2967   ToolkitTestApplication application;
2968   tet_infoline("UtcDaliVisualSetTransform: ColorVisual");
2969
2970   VisualFactory factory = VisualFactory::Get();
2971   Property::Map propertyMap;
2972   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
2973   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
2974   Visual::Base visual = factory.CreateVisual(propertyMap);
2975   TestTransform(application, visual);
2976   TestMixColor(visual, ColorVisual::Property::MIX_COLOR, Color::BLUE);
2977
2978   END_TEST;
2979 }
2980
2981 int UtcDaliVisualSetTransform1(void)
2982 {
2983   ToolkitTestApplication application;
2984   tet_infoline("UtcDaliVisualSetTransform: PrimitiveVisual");
2985
2986   VisualFactory factory = VisualFactory::Get();
2987   Property::Map propertyMap;
2988   propertyMap[Toolkit::Visual::Property::TYPE]      = Visual::PRIMITIVE;
2989   propertyMap[PrimitiveVisual::Property::MIX_COLOR] = Color::WHITE;
2990   propertyMap[PrimitiveVisual::Property::SHAPE]     = PrimitiveVisual::Shape::SPHERE;
2991   propertyMap[PrimitiveVisual::Property::SLICES]    = 10;
2992   propertyMap[PrimitiveVisual::Property::STACKS]    = 10;
2993   Visual::Base visual                               = factory.CreateVisual(propertyMap);
2994   TestTransform(application, visual);
2995   TestMixColor(visual, PrimitiveVisual::Property::MIX_COLOR, Color::WHITE);
2996
2997   END_TEST;
2998 }
2999
3000 int UtcDaliVisualSetTransform2(void)
3001 {
3002   ToolkitTestApplication application;
3003   tet_infoline("UtcDaliVisualSetTransform: GradientVisual");
3004
3005   VisualFactory factory = VisualFactory::Get();
3006   Property::Map propertyMap;
3007   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::GRADIENT);
3008   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::GREEN);
3009
3010   Property::Array stopOffsets;
3011   stopOffsets.PushBack(0.0f);
3012   stopOffsets.PushBack(0.3f);
3013   stopOffsets.PushBack(0.6f);
3014   stopOffsets.PushBack(0.8f);
3015   stopOffsets.PushBack(1.0f);
3016   propertyMap.Insert(GradientVisual::Property::STOP_OFFSET, stopOffsets);
3017
3018   Property::Array stopColors;
3019   stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 255.f) / 255.f);
3020   stopColors.PushBack(Vector4(196.f, 198.f, 71.f, 122.f) / 255.f);
3021   stopColors.PushBack(Vector4(214.f, 37.f, 139.f, 191.f) / 255.f);
3022   stopColors.PushBack(Vector4(129.f, 198.f, 193.f, 150.f) / 255.f);
3023   stopColors.PushBack(Color::YELLOW);
3024   propertyMap.Insert(GradientVisual::Property::STOP_COLOR, stopColors);
3025   propertyMap.Insert(GradientVisual::Property::CENTER, Vector2(0.5f, 0.5f));
3026   propertyMap.Insert(GradientVisual::Property::RADIUS, 1.414f);
3027   Visual::Base visual = factory.CreateVisual(propertyMap);
3028   TestTransform(application, visual);
3029   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::GREEN);
3030
3031   END_TEST;
3032 }
3033
3034 int UtcDaliVisualSetTransform3(void)
3035 {
3036   ToolkitTestApplication application;
3037   tet_infoline("UtcDaliVisualSetTransform: BorderVisual");
3038
3039   VisualFactory factory = VisualFactory::Get();
3040   Property::Map propertyMap;
3041   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::BORDER);
3042   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::MAGENTA);
3043   propertyMap.Insert(BorderVisual::Property::COLOR, Vector4(0.f, 1.f, 0.f, 0.6f));
3044   propertyMap.Insert(BorderVisual::Property::SIZE, 3.0f);
3045   Visual::Base visual = factory.CreateVisual(propertyMap);
3046   TestTransform(application, visual);
3047   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::MAGENTA);
3048
3049   END_TEST;
3050 }
3051
3052 int UtcDaliVisualSetTransform4(void)
3053 {
3054   ToolkitTestApplication application;
3055   tet_infoline("UtcDaliVisualSetTransform: MeshVisual");
3056
3057   VisualFactory factory = VisualFactory::Get();
3058   Property::Map propertyMap;
3059   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::MESH);
3060   propertyMap.Insert(Visual::Property::MIX_COLOR, Color::CYAN);
3061
3062   propertyMap.Insert("objectUrl", TEST_OBJ_FILE_NAME);
3063   propertyMap.Insert("materialUrl", TEST_MTL_FILE_NAME);
3064   propertyMap.Insert("texturesPath", TEST_RESOURCE_LOCATION);
3065   propertyMap.Insert("shadingMode", MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING);
3066   propertyMap.Insert("lightPosition", Vector3(5.0f, 10.0f, 15.0f));
3067   Visual::Base visual = factory.CreateVisual(propertyMap);
3068   TestTransform(application, visual);
3069   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::CYAN);
3070
3071   END_TEST;
3072 }
3073
3074 int UtcDaliVisualSetTransform5(void)
3075 {
3076   ToolkitTestApplication application;
3077   tet_infoline("UtcDaliVisualSetTransform: ImageVisual for URL ");
3078
3079   VisualFactory factory = VisualFactory::Get();
3080   Property::Map propertyMap;
3081   propertyMap[Toolkit::Visual::Property::TYPE]                     = Toolkit::Visual::IMAGE;
3082   propertyMap[Visual::Property::MIX_COLOR]                         = Color::YELLOW;
3083   propertyMap[Toolkit::ImageVisual::Property::URL]                 = TEST_IMAGE_FILE_NAME;
3084   propertyMap[Toolkit::ImageVisual::Property::DESIRED_WIDTH]       = 100.0f;
3085   propertyMap[Toolkit::ImageVisual::Property::DESIRED_HEIGHT]      = 100.0f;
3086   propertyMap[Toolkit::ImageVisual::Property::FITTING_MODE]        = FittingMode::SCALE_TO_FILL;
3087   propertyMap[Toolkit::ImageVisual::Property::SAMPLING_MODE]       = SamplingMode::BOX_THEN_LINEAR;
3088   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3089   Visual::Base visual                                              = factory.CreateVisual(propertyMap);
3090   TestTransform(application, visual);
3091   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::YELLOW);
3092
3093   END_TEST;
3094 }
3095
3096 int UtcDaliVisualSetTransform6(void)
3097 {
3098   ToolkitTestApplication application;
3099   tet_infoline("UtcDaliVisualSetTransform: NPatch visual");
3100
3101   VisualFactory factory = VisualFactory::Get();
3102   Property::Map propertyMap;
3103   propertyMap[Toolkit::Visual::Property::TYPE]                     = Toolkit::Visual::IMAGE;
3104   propertyMap[Toolkit::ImageVisual::Property::URL]                 = TEST_NPATCH_FILE_NAME;
3105   propertyMap[Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3106   Visual::Base visual                                              = factory.CreateVisual(propertyMap);
3107   TestTransform(application, visual);
3108   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::WHITE);
3109
3110   END_TEST;
3111 }
3112
3113 int UtcDaliVisualTestTransformPoliciesAsStrings(void)
3114 {
3115   ToolkitTestApplication application;
3116   tet_infoline("UtcDaliVisualTestTransformPoliciesAsStrings: Use a ColorVisual and test the offset and size policies as strings");
3117
3118   VisualFactory factory = VisualFactory::Get();
3119   Property::Map propertyMap;
3120   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3121   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3122   Visual::Base visual = factory.CreateVisual(propertyMap);
3123
3124   Property::Map transform;
3125   transform["offsetPolicy"] = Property::Array().Add("ABSOLUTE").Add("RELATIVE");
3126   transform["sizePolicy"]   = Property::Array().Add("RELATIVE").Add("ABSOLUTE");
3127   visual.SetTransformAndSize(transform, Vector2(100, 100));
3128
3129   Dali::Property::Map visualMap;
3130   visual.CreatePropertyMap(visualMap);
3131   Property::Value*     value = visualMap.Find(Dali::Toolkit::Visual::Property::TRANSFORM);
3132   Dali::Property::Map* map   = value->GetMap();
3133   DALI_TEST_CHECK(map);
3134
3135   {
3136     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::OFFSET_POLICY);
3137     DALI_TEST_CHECK(typeValue);
3138     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::ABSOLUTE, Toolkit::Visual::Transform::Policy::RELATIVE), TEST_LOCATION);
3139   }
3140   {
3141     Property::Value* typeValue = map->Find(Toolkit::Visual::Transform::Property::SIZE_POLICY);
3142     DALI_TEST_CHECK(typeValue);
3143     DALI_TEST_EQUALS(typeValue->Get<Vector2>(), Vector2(Toolkit::Visual::Transform::Policy::RELATIVE, Toolkit::Visual::Transform::Policy::ABSOLUTE), TEST_LOCATION);
3144   }
3145
3146   END_TEST;
3147 }
3148
3149 int UtcDaliNPatchVisualCustomShader(void)
3150 {
3151   ToolkitTestApplication application;
3152   tet_infoline("NPatchVisual with custom shader");
3153
3154   VisualFactory     factory = VisualFactory::Get();
3155   Property::Map     properties;
3156   Property::Map     shader;
3157   const std::string vertexShader                                   = "Foobar";
3158   const std::string fragmentShader                                 = "Foobar";
3159   shader[Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER] = fragmentShader;
3160   shader[Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER]   = vertexShader;
3161
3162   Property::Map transformMap;
3163   transformMap["size"]                    = Vector2(0.5f, 0.5f);
3164   transformMap["offset"]                  = Vector2(20.0f, 0.0f);
3165   transformMap["offsetPolicy"]            = Vector2(Visual::Transform::Policy::ABSOLUTE, Visual::Transform::Policy::ABSOLUTE);
3166   transformMap["anchorPoint"]             = Align::CENTER;
3167   transformMap["origin"]                  = Align::CENTER;
3168   transformMap["extraSize"]               = Vector2(0.0f, 50.0f);
3169   properties[Visual::Property::TRANSFORM] = transformMap;
3170
3171   properties[Visual::Property::TYPE]                     = Visual::IMAGE;
3172   properties[Visual::Property::MIX_COLOR]                = Color::BLUE;
3173   properties[Visual::Property::SHADER]                   = shader;
3174   properties[ImageVisual::Property::URL]                 = TEST_NPATCH_FILE_NAME;
3175   properties[ImageVisual::Property::SYNCHRONOUS_LOADING] = true;
3176
3177   Visual::Base visual = factory.CreateVisual(properties);
3178   TestMixColor(visual, Visual::Property::MIX_COLOR, Color::BLUE);
3179
3180   // trigger creation through setting on stage
3181   DummyControl        dummy     = DummyControl::New(true);
3182   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(dummy.GetImplementation());
3183   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3184   dummyImpl.SetLayout(DummyControl::Property::TEST_VISUAL, transformMap);
3185   dummy.SetProperty(Actor::Property::SIZE, Vector2(2000.f, 2000.f));
3186   dummy.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3187   application.GetScene().Add(dummy);
3188   application.SendNotification();
3189
3190   Renderer        renderer = dummy.GetRendererAt(0);
3191   Shader          shader2  = renderer.GetShader();
3192   Property::Value value    = shader2.GetProperty(Shader::Property::PROGRAM);
3193   Property::Map*  map      = value.GetMap();
3194   DALI_TEST_CHECK(map);
3195
3196   Property::Index index = VisualRenderer::Property::TRANSFORM_SIZE;
3197   DALI_TEST_EQUALS(renderer.GetProperty(index), Property::Value(Vector2(0.5, 0.5)), 0.001, TEST_LOCATION);
3198
3199   Property::Value* fragment = map->Find("fragment"); // fragment key name from shader-impl.cpp
3200   DALI_TEST_EQUALS(fragmentShader, fragment->Get<std::string>(), TEST_LOCATION);
3201
3202   Property::Value* vertex = map->Find("vertex"); // vertex key name from shader-impl.cpp
3203   DALI_TEST_EQUALS(vertexShader, vertex->Get<std::string>(), TEST_LOCATION);
3204
3205   Vector2 extraSize = renderer.GetProperty<Vector2>(VisualRenderer::Property::EXTRA_SIZE);
3206   DALI_TEST_EQUALS(extraSize, Vector2(0.0f, 50.0f), TEST_LOCATION);
3207
3208   END_TEST;
3209 }
3210
3211 int UtcDaliGradientVisualBlendMode(void)
3212 {
3213   ToolkitTestApplication application;
3214   VisualFactory          factory = VisualFactory::Get();
3215
3216   Visual::Base opaqueGradientVisual = factory.CreateVisual(
3217     Property::Map().Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT).Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f)).Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f)).Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Color::GREEN)));
3218
3219   Visual::Base alphaGradientVisual = factory.CreateVisual(
3220     Property::Map().Add(Toolkit::Visual::Property::TYPE, Visual::GRADIENT).Add(GradientVisual::Property::START_POSITION, Vector2(-0.5f, -0.5f)).Add(GradientVisual::Property::END_POSITION, Vector2(0.5f, 0.5f)).Add(GradientVisual::Property::STOP_COLOR, Property::Array().Add(Color::RED).Add(Vector4(1.0f, 1.0f, 1.0f, 0.5f))));
3221
3222   DummyControl control = DummyControl::New(true);
3223   control.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
3224   application.GetScene().Add(control);
3225
3226   Impl::DummyControl& dummyImpl = static_cast<Impl::DummyControl&>(control.GetImplementation());
3227   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, opaqueGradientVisual);
3228   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL2, alphaGradientVisual);
3229
3230   application.SendNotification();
3231   application.Render();
3232
3233   // Control should have two renderers, the first one is opaque so our blending mode should be off, the second one has some alpha so should be set to automatic
3234   DALI_TEST_EQUALS(2u, control.GetRendererCount(), TEST_LOCATION);
3235   DALI_TEST_EQUALS(control.GetRendererAt(0).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::OFF, TEST_LOCATION);
3236   DALI_TEST_EQUALS(control.GetRendererAt(1).GetProperty(Renderer::Property::BLEND_MODE).Get<int>(), (int)BlendMode::AUTO, TEST_LOCATION);
3237
3238   END_TEST;
3239 }
3240
3241 int UtcDaliVisualRendererRemovalAndReAddition(void)
3242 {
3243   ToolkitTestApplication application;
3244   tet_infoline("UtcDaliVisualRendererRemoval");
3245
3246   VisualFactory factory = VisualFactory::Get();
3247   Property::Map propertyMap;
3248   propertyMap.Insert(Visual::Property::TYPE, Visual::COLOR);
3249   propertyMap.Insert(ColorVisual::Property::MIX_COLOR, Color::BLUE);
3250   Visual::Base visual = factory.CreateVisual(propertyMap);
3251
3252   visual.SetDepthIndex(1);
3253
3254   DummyControl        dummyControl = DummyControl::New(true);
3255   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3256   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, visual);
3257   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3258
3259   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3260   tet_infoline("Add control with visual to stage and check renderer count is 1");
3261
3262   application.GetScene().Add(dummyControl);
3263
3264   application.SendNotification();
3265   application.Render();
3266
3267   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3268
3269   tet_infoline("Remove control with visual from stage and check renderer count is 0");
3270   application.GetScene().Remove(dummyControl);
3271   application.SendNotification();
3272   application.Render();
3273
3274   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3275
3276   tet_infoline("Re-add control with visual to stage and check renderer count is still 1");
3277
3278   application.GetScene().Add(dummyControl);
3279
3280   application.SendNotification();
3281   application.Render();
3282
3283   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3284
3285   END_TEST;
3286 }
3287
3288 int UtcDaliVisualTextVisualRender(void)
3289 {
3290   ToolkitTestApplication application;
3291   tet_infoline("UtcDaliVisualTextVisualRender");
3292
3293   VisualFactory factory = VisualFactory::Get();
3294   Property::Map propertyMap;
3295   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3296   propertyMap.Insert("mixColor", Color::WHITE);
3297   propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3298   propertyMap.Insert("enableMarkup", false);
3299   propertyMap.Insert("text", "Hello world");
3300   propertyMap.Insert("fontFamily", "TizenSans");
3301
3302   Property::Map fontStyleMapSet;
3303   fontStyleMapSet.Insert("weight", "bold");
3304   propertyMap.Insert("fontStyle", fontStyleMapSet);
3305
3306   propertyMap.Insert("pointSize", 12.f);
3307   propertyMap.Insert("multiLine", true);
3308   propertyMap.Insert("horizontalAlignment", "CENTER");
3309   propertyMap.Insert("verticalAlignment", "CENTER");
3310   propertyMap.Insert("textColor", Color::RED);
3311   Visual::Base textVisual = factory.CreateVisual(propertyMap);
3312   textVisual.SetDepthIndex(1);
3313
3314   DummyControl        dummyControl = DummyControl::New(true);
3315   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3316   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3317   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3318
3319   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3320   dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3321
3322   application.GetScene().Add(dummyControl);
3323   application.SendNotification();
3324   application.Render();
3325
3326   // Create a texture bigger than the maximum allowed by the image atlas. Used to increase coverage.
3327   propertyMap.Clear();
3328   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3329   propertyMap.Insert(TextVisual::Property::ENABLE_MARKUP, true);
3330   propertyMap.Insert(TextVisual::Property::TEXT, "<font family='TizenSans' size='12'>Hello world</font>");
3331   propertyMap.Insert(TextVisual::Property::MULTI_LINE, true);
3332
3333   Property::Map transformMap;
3334   transformMap.Insert("size", Vector2(0.5f, 0.5f));
3335   propertyMap.Insert(Visual::Property::TRANSFORM, transformMap);
3336
3337   textVisual = factory.CreateVisual(propertyMap);
3338   textVisual.SetDepthIndex(1);
3339
3340   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3341   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(720.f, 640.f));
3342
3343   application.SendNotification(); // force process events to ensure text visual
3344   // adds renderer to the dummy control in OnRelayout
3345   application.Render();
3346
3347   Renderer        renderer = dummyControl.GetRendererAt(0u);
3348   Property::Index index    = renderer.GetPropertyIndex("transformSize");
3349
3350   tet_infoline("Test that the TextVisual has NOT overridden what was set by developer");
3351   DALI_TEST_EQUALS(renderer.GetProperty<Vector2>(index), Vector2(0.5f, 0.5f), 0.001f, TEST_LOCATION);
3352
3353   END_TEST;
3354 }
3355
3356 int UtcDaliVisualTextVisualDisableEnable(void)
3357 {
3358   ToolkitTestApplication application;
3359   tet_infoline("UtcDaliVisualTextVisualDisableEnable Ensure Text visible can be re-enabled");
3360
3361   VisualFactory factory = VisualFactory::Get();
3362   Property::Map propertyMap;
3363   propertyMap.Insert(Toolkit::Visual::Property::TYPE, Visual::TEXT);
3364   propertyMap.Insert("mixColor", Color::WHITE);
3365   propertyMap.Insert("renderingBackend", static_cast<int>(Toolkit::DevelText::DEFAULT_RENDERING_BACKEND));
3366   propertyMap.Insert("enableMarkup", false);
3367   propertyMap.Insert("text", "Hello world");
3368   propertyMap.Insert("fontFamily", "TizenSans");
3369
3370   Property::Map fontStyleMapSet;
3371   fontStyleMapSet.Insert("weight", "bold");
3372   propertyMap.Insert("fontStyle", fontStyleMapSet);
3373
3374   propertyMap.Insert("pointSize", 12.f);
3375   propertyMap.Insert("multiLine", true);
3376   propertyMap.Insert("horizontalAlignment", "CENTER");
3377   propertyMap.Insert("verticalAlignment", "CENTER");
3378   propertyMap.Insert("textColor", Color::RED);
3379   Visual::Base textVisual = factory.CreateVisual(propertyMap);
3380   textVisual.SetDepthIndex(1);
3381
3382   DummyControl        dummyControl = DummyControl::New(true);
3383   Impl::DummyControl& dummyImpl    = static_cast<Impl::DummyControl&>(dummyControl.GetImplementation());
3384   dummyImpl.RegisterVisual(DummyControl::Property::TEST_VISUAL, textVisual);
3385   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3386
3387   dummyControl.SetProperty(Actor::Property::SIZE, Vector2(200.f, 200.f));
3388   dummyControl.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
3389
3390   application.GetScene().Add(dummyControl);
3391   application.SendNotification();
3392   application.Render();
3393
3394   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3395
3396   dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, false);
3397
3398   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 0, TEST_LOCATION);
3399
3400   dummyImpl.EnableVisual(DummyControl::Property::TEST_VISUAL, true);
3401
3402   DALI_TEST_EQUALS(dummyControl.GetRendererCount(), 1, TEST_LOCATION);
3403
3404   END_TEST;
3405 }
3406
3407 int UtcDaliVisualPremultipliedAlpha(void)
3408 {
3409   ToolkitTestApplication application;
3410   tet_infoline("UtcDaliVisualPremultipliedAlpha");
3411
3412   VisualFactory factory = VisualFactory::Get();
3413
3414   // image visual, test default value ( true )
3415   {
3416     Visual::Base imageVisual = factory.CreateVisual(
3417       Property::Map()
3418         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3419         .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME));
3420
3421     Dali::Property::Map visualMap;
3422     imageVisual.CreatePropertyMap(visualMap);
3423     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3424
3425     // test values
3426     DALI_TEST_CHECK(value);
3427     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3428   }
3429
3430   // image visual, override premultiplied
3431   {
3432     Visual::Base imageVisual = factory.CreateVisual(
3433       Property::Map()
3434         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3435         .Add(ImageVisual::Property::URL, TEST_IMAGE_FILE_NAME)
3436         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3437
3438     Dali::Property::Map visualMap;
3439     imageVisual.CreatePropertyMap(visualMap);
3440     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3441
3442     // test values
3443     DALI_TEST_CHECK(value);
3444     DALI_TEST_EQUALS(value->Get<bool>(), false, TEST_LOCATION);
3445   }
3446
3447   // svg visual ( premultiplied alpha by default is true, and cannot change value )
3448   {
3449     Visual::Base imageVisual = factory.CreateVisual(
3450       Property::Map()
3451         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3452         .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME));
3453
3454     Dali::Property::Map visualMap;
3455     imageVisual.CreatePropertyMap(visualMap);
3456     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3457
3458     // test values
3459     DALI_TEST_CHECK(value);
3460     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3461   }
3462   {
3463     Visual::Base imageVisual = factory.CreateVisual(
3464       Property::Map()
3465         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3466         .Add(ImageVisual::Property::URL, TEST_SVG_FILE_NAME)
3467         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3468
3469     Dali::Property::Map visualMap;
3470     imageVisual.CreatePropertyMap(visualMap);
3471     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3472
3473     // test values
3474     DALI_TEST_CHECK(value);
3475     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3476   }
3477
3478   // animated vector visual ( premultiplied alpha by default is true, and cannot change value )
3479   {
3480     Visual::Base imageVisual = factory.CreateVisual(
3481       Property::Map()
3482         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3483         .Add(ImageVisual::Property::URL, "something.json"));
3484
3485     Dali::Property::Map visualMap;
3486     imageVisual.CreatePropertyMap(visualMap);
3487     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3488
3489     // test values
3490     DALI_TEST_CHECK(value);
3491     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3492   }
3493   {
3494     Visual::Base imageVisual = factory.CreateVisual(
3495       Property::Map()
3496         .Add(Toolkit::Visual::Property::TYPE, Visual::IMAGE)
3497         .Add(ImageVisual::Property::URL, "something.json")
3498         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3499
3500     Dali::Property::Map visualMap;
3501     imageVisual.CreatePropertyMap(visualMap);
3502     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3503
3504     // test values
3505     DALI_TEST_CHECK(value);
3506     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3507   }
3508
3509   // text visual ( premultiplied alpha by default is true, and cannot change value )
3510   {
3511     Visual::Base textVisual = factory.CreateVisual(
3512       Property::Map()
3513         .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3514         .Add(TextVisual::Property::TEXT, "Text"));
3515
3516     Dali::Property::Map visualMap;
3517     textVisual.CreatePropertyMap(visualMap);
3518     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3519
3520     // test values
3521     DALI_TEST_CHECK(value);
3522     DALI_TEST_EQUALS(value->Get<bool>(), true, TEST_LOCATION);
3523   }
3524   {
3525     Visual::Base textVisual = factory.CreateVisual(
3526       Property::Map()
3527         .Add(Toolkit::Visual::Property::TYPE, Visual::TEXT)
3528         .Add(TextVisual::Property::TEXT, "Text")
3529         .Add(Visual::Property::PREMULTIPLIED_ALPHA, false));
3530
3531     Dali::Property::Map visualMap;
3532     textVisual.CreatePropertyMap(visualMap);
3533     Property::Value* value = visualMap.Find(Visual::Property::PREMULTIPLIED_ALPHA);
3534
3535     // test values