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