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