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