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