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