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