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