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