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