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