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