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