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