automated-tests/src/dali/utc-Dali-Scripting.cpp

   1 /*
   2  * Copyright (c) 2014 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
  18 #include <iostream>
  19
  20 #include <stdlib.h>
  21 #include <dali/public-api/dali-core.h>
  22 #include <dali-test-suite-utils.h>
  23
  24 using namespace Dali;
  25 using namespace Dali::Scripting;
  26
  27 namespace
  28 {
  29
  30 const StringEnum< int > COLOR_MODE_VALUES[] =
  31 {
  32     { "USE_OWN_COLOR", USE_OWN_COLOR },
  33     { "USE_PARENT_COLOR", USE_PARENT_COLOR },
  34     { "USE_OWN_MULTIPLY_PARENT_COLOR", USE_OWN_MULTIPLY_PARENT_COLOR },
  35     { "USE_OWN_MULTIPLY_PARENT_ALPHA", USE_OWN_MULTIPLY_PARENT_ALPHA },
  36 };
  37 const unsigned int COLOR_MODE_VALUES_COUNT = sizeof( COLOR_MODE_VALUES ) / sizeof( COLOR_MODE_VALUES[0] );
  38
  39 const StringEnum< int > POSITION_INHERITANCE_MODE_VALUES[] =
  40 {
  41     { "INHERIT_PARENT_POSITION", INHERIT_PARENT_POSITION },
  42     { "USE_PARENT_POSITION", USE_PARENT_POSITION },
  43     { "USE_PARENT_POSITION_PLUS_LOCAL_POSITION", USE_PARENT_POSITION_PLUS_LOCAL_POSITION },
  44     { "DONT_INHERIT_POSITION", DONT_INHERIT_POSITION },
  45 };
  46 const unsigned int POSITION_INHERITANCE_MODE_VALUES_COUNT = sizeof( POSITION_INHERITANCE_MODE_VALUES ) / sizeof( POSITION_INHERITANCE_MODE_VALUES[0] );
  47
  48 const StringEnum< int > DRAW_MODE_VALUES[] =
  49 {
  50     { "NORMAL", DrawMode::NORMAL },
  51     { "OVERLAY", DrawMode::OVERLAY },
  52     { "STENCIL", DrawMode::STENCIL },
  53 };
  54 const unsigned int DRAW_MODE_VALUES_COUNT = sizeof( DRAW_MODE_VALUES ) / sizeof( DRAW_MODE_VALUES[0] );
  55
  56
  57 //////////////////////////////////////////////////////////////////////////////
  58 // Helpers for string to enum comparisons for Image and ImageAttributes
  59 //////////////////////////////////////////////////////////////////////////////
  60
  61 /**
  62  * Template to check enumerations of type T, with a class of type X
  63  */
  64 template< typename T, typename X >
  65 void TestEnumStrings(
  66   Property::Map& map,                       // The map used to create instance of type X
  67   const StringEnum< int >* values,          // An array of string values
  68   unsigned int num,                         // Number of items in the array
  69   T ( X::*method )() const,                 // The member method of X to call to get the enum
  70   X ( *creator ) ( const Property::Value& ) // The method which creates an instance of type X
  71 )
  72 {
  73   const unsigned int lastIndex( map.Count() - 1 );
  74   const std::string& key = map.GetKey( lastIndex );
  75   Property::Value& value = map.GetValue( lastIndex );
  76
  77   for ( unsigned int i = 0; i < num; ++i )
  78   {
  79     value = values[i].string;
  80     tet_printf("Checking: %s: %s\n", key.c_str(), values[i].string );
  81     X instance = creator( map );
  82     DALI_TEST_EQUALS( values[i].value, ( instance.*method )(), TEST_LOCATION );
  83   }
  84 }
  85
  86 /// Helper method to create ResourceImage using property
  87 ResourceImage NewResourceImage( const Property::Value& map )
  88 {
  89   ResourceImage image = ResourceImage::DownCast( NewImage( map ) );
  90   return image;
  91 }
  92
  93 /// Helper method to create ResourceImage using property
  94 BitmapImage NewBitmapImage( const Property::Value& map )
  95 {
  96   BitmapImage image = BitmapImage::DownCast( NewImage( map ) );
  97   return image;
  98 }
  99
 100 /// Helper method to create ImageAttributes using an Image
 101 ImageAttributes NewImageAttributes( const Property::Value& map )
 102 {
 103   ResourceImage image = ResourceImage::DownCast( NewImage( map ) );
 104   return image.GetAttributes();
 105 }
 106
 107 //////////////////////////////////////////////////////////////////////////////
 108 // Helpers for string to enum comparisons for Actor to Property::Map
 109 //////////////////////////////////////////////////////////////////////////////
 110
 111 /**
 112  * Template to check enumerations of type T
 113  */
 114 template< typename T >
 115 void TestEnumStrings(
 116   const char * const keyName,               // The name of the key to check
 117   TestApplication& application,             // Reference to the application class
 118   const StringEnum< int >* values,          // An array of string values
 119   unsigned int num,                         // Number of items in the array
 120   void ( Actor::*method )( T )              // The Actor member method to set the enumeration
 121 )
 122 {
 123   for ( unsigned int i = 0; i < num; ++i )
 124   {
 125     tet_printf("Checking: %s: %s\n", keyName, values[i].string );
 126
 127     Actor actor = Actor::New();
 128     (actor.*method)( ( T ) values[i].value );
 129
 130     Stage::GetCurrent().Add( actor );
 131     application.SendNotification();
 132     application.Render();
 133
 134     Property::Map map;
 135     CreatePropertyMap( actor, map );
 136
 137     DALI_TEST_CHECK( map.Count() );
 138     Property::Value value( map );
 139     DALI_TEST_CHECK( value.HasKey( keyName ) );
 140     DALI_TEST_EQUALS( value.GetValue( keyName ).Get< std::string >(), values[i].string, TEST_LOCATION );
 141
 142     Stage::GetCurrent().Remove( actor );
 143   }
 144 }
 145
 146 //////////////////////////////////////////////////////////////////////////////
 147
 148
 149 } // anon namespace
 150
 151
 152
 153 int UtcDaliScriptingGetColorMode(void)
 154 {
 155   TestApplication application;
 156
 157   for ( unsigned int i = 0; i < COLOR_MODE_VALUES_COUNT; ++i )
 158   {
 159     tet_printf( "Checking %s == %d\n", COLOR_MODE_VALUES[i].string, COLOR_MODE_VALUES[i].value );
 160     DALI_TEST_EQUALS( COLOR_MODE_VALUES[i].value, GetColorMode( COLOR_MODE_VALUES[i].string ), TEST_LOCATION );
 161     DALI_TEST_EQUALS( COLOR_MODE_VALUES[i].string, GetColorMode( (ColorMode) COLOR_MODE_VALUES[i].value ), TEST_LOCATION );
 162   }
 163
 164   try
 165   {
 166     (void)GetColorMode("INVALID_ARG");
 167     tet_result( TET_FAIL );
 168   }
 169   catch ( DaliException& e )
 170   {
 171     DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
 172   }
 173   END_TEST;
 174 }
 175
 176 int UtcDaliScriptingGetPositionInheritanceMode(void)
 177 {
 178   TestApplication application;
 179
 180   for ( unsigned int i = 0; i < POSITION_INHERITANCE_MODE_VALUES_COUNT; ++i )
 181   {
 182     tet_printf( "Checking %s == %d\n", POSITION_INHERITANCE_MODE_VALUES[i].string, POSITION_INHERITANCE_MODE_VALUES[i].value );
 183     DALI_TEST_EQUALS( POSITION_INHERITANCE_MODE_VALUES[i].value, GetPositionInheritanceMode( POSITION_INHERITANCE_MODE_VALUES[i].string ), TEST_LOCATION );
 184     DALI_TEST_EQUALS( POSITION_INHERITANCE_MODE_VALUES[i].string, GetPositionInheritanceMode( (PositionInheritanceMode) POSITION_INHERITANCE_MODE_VALUES[i].value ), TEST_LOCATION );
 185   }
 186
 187   try
 188   {
 189     (void)GetPositionInheritanceMode("INVALID_ARG");
 190     tet_result( TET_FAIL );
 191   }
 192   catch ( DaliException& e )
 193   {
 194     DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
 195   }
 196   END_TEST;
 197 }
 198
 199
 200 int UtcDaliScriptingGetDrawMode(void)
 201 {
 202   TestApplication application;
 203
 204   for ( unsigned int i = 0; i < DRAW_MODE_VALUES_COUNT; ++i )
 205   {
 206     tet_printf( "Checking %s == %d\n", DRAW_MODE_VALUES[i].string, DRAW_MODE_VALUES[i].value );
 207     DALI_TEST_EQUALS( DRAW_MODE_VALUES[i].value, GetDrawMode( DRAW_MODE_VALUES[i].string ), TEST_LOCATION );
 208     DALI_TEST_EQUALS( DRAW_MODE_VALUES[i].string, GetDrawMode( (DrawMode::Type) DRAW_MODE_VALUES[i].value ), TEST_LOCATION );
 209   }
 210
 211   try
 212   {
 213     (void)GetDrawMode("INVALID_ARG");
 214     tet_result( TET_FAIL );
 215   }
 216   catch ( DaliException& e )
 217   {
 218     DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
 219   }
 220   END_TEST;
 221 }
 222
 223 int UtcDaliScriptingGetAnchorConstant(void)
 224 {
 225   TestApplication application;
 226
 227   DALI_TEST_EQUALS( Dali::ParentOrigin::BACK_TOP_LEFT, GetAnchorConstant( "BACK_TOP_LEFT" ), TEST_LOCATION );
 228   DALI_TEST_EQUALS( Dali::ParentOrigin::BACK_TOP_CENTER, GetAnchorConstant( "BACK_TOP_CENTER" ), TEST_LOCATION );
 229   DALI_TEST_EQUALS( Dali::ParentOrigin::BACK_TOP_RIGHT, GetAnchorConstant( "BACK_TOP_RIGHT" ), TEST_LOCATION );
 230   DALI_TEST_EQUALS( Dali::ParentOrigin::BACK_CENTER_LEFT, GetAnchorConstant( "BACK_CENTER_LEFT" ), TEST_LOCATION );
 231   DALI_TEST_EQUALS( Dali::ParentOrigin::BACK_CENTER, GetAnchorConstant( "BACK_CENTER" ), TEST_LOCATION );
 232   DALI_TEST_EQUALS( Dali::ParentOrigin::BACK_CENTER_RIGHT, GetAnchorConstant( "BACK_CENTER_RIGHT" ), TEST_LOCATION );
 233   DALI_TEST_EQUALS( Dali::ParentOrigin::BACK_BOTTOM_LEFT, GetAnchorConstant( "BACK_BOTTOM_LEFT" ), TEST_LOCATION );
 234   DALI_TEST_EQUALS( Dali::ParentOrigin::BACK_BOTTOM_CENTER, GetAnchorConstant( "BACK_BOTTOM_CENTER" ), TEST_LOCATION );
 235   DALI_TEST_EQUALS( Dali::ParentOrigin::BACK_BOTTOM_RIGHT, GetAnchorConstant( "BACK_BOTTOM_RIGHT" ), TEST_LOCATION );
 236   DALI_TEST_EQUALS( Dali::ParentOrigin::TOP_LEFT, GetAnchorConstant( "TOP_LEFT" ), TEST_LOCATION );
 237   DALI_TEST_EQUALS( Dali::ParentOrigin::TOP_CENTER, GetAnchorConstant( "TOP_CENTER" ), TEST_LOCATION );
 238   DALI_TEST_EQUALS( Dali::ParentOrigin::TOP_RIGHT, GetAnchorConstant( "TOP_RIGHT" ), TEST_LOCATION );
 239   DALI_TEST_EQUALS( Dali::ParentOrigin::CENTER_LEFT, GetAnchorConstant( "CENTER_LEFT" ), TEST_LOCATION );
 240   DALI_TEST_EQUALS( Dali::ParentOrigin::CENTER, GetAnchorConstant( "CENTER" ), TEST_LOCATION );
 241   DALI_TEST_EQUALS( Dali::ParentOrigin::CENTER_RIGHT, GetAnchorConstant( "CENTER_RIGHT" ), TEST_LOCATION );
 242   DALI_TEST_EQUALS( Dali::ParentOrigin::BOTTOM_LEFT, GetAnchorConstant( "BOTTOM_LEFT" ), TEST_LOCATION );
 243   DALI_TEST_EQUALS( Dali::ParentOrigin::BOTTOM_CENTER, GetAnchorConstant( "BOTTOM_CENTER" ), TEST_LOCATION );
 244   DALI_TEST_EQUALS( Dali::ParentOrigin::BOTTOM_RIGHT, GetAnchorConstant( "BOTTOM_RIGHT" ), TEST_LOCATION );
 245   DALI_TEST_EQUALS( Dali::ParentOrigin::FRONT_TOP_LEFT, GetAnchorConstant( "FRONT_TOP_LEFT" ), TEST_LOCATION );
 246   DALI_TEST_EQUALS( Dali::ParentOrigin::FRONT_TOP_CENTER, GetAnchorConstant( "FRONT_TOP_CENTER" ), TEST_LOCATION );
 247   DALI_TEST_EQUALS( Dali::ParentOrigin::FRONT_TOP_RIGHT, GetAnchorConstant( "FRONT_TOP_RIGHT" ), TEST_LOCATION );
 248   DALI_TEST_EQUALS( Dali::ParentOrigin::FRONT_CENTER_LEFT, GetAnchorConstant( "FRONT_CENTER_LEFT" ), TEST_LOCATION );
 249   DALI_TEST_EQUALS( Dali::ParentOrigin::FRONT_CENTER, GetAnchorConstant( "FRONT_CENTER" ), TEST_LOCATION );
 250   DALI_TEST_EQUALS( Dali::ParentOrigin::FRONT_CENTER_RIGHT, GetAnchorConstant( "FRONT_CENTER_RIGHT" ), TEST_LOCATION );
 251   DALI_TEST_EQUALS( Dali::ParentOrigin::FRONT_BOTTOM_LEFT, GetAnchorConstant( "FRONT_BOTTOM_LEFT" ), TEST_LOCATION );
 252   DALI_TEST_EQUALS( Dali::ParentOrigin::FRONT_BOTTOM_CENTER, GetAnchorConstant( "FRONT_BOTTOM_CENTER" ), TEST_LOCATION );
 253   DALI_TEST_EQUALS( Dali::ParentOrigin::FRONT_BOTTOM_RIGHT, GetAnchorConstant( "FRONT_BOTTOM_RIGHT" ), TEST_LOCATION );
 254
 255   try
 256   {
 257     (void)GetAnchorConstant("INVALID_ARG");
 258     tet_result( TET_FAIL );
 259   }
 260   catch ( DaliException& e )
 261   {
 262     DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
 263   }
 264   END_TEST;
 265 }
 266
 267 int UtcDaliScriptingNewImageNegative(void)
 268 {
 269   TestApplication application;
 270
 271   // Invalid filename
 272   try
 273   {
 274     Property::Map map;
 275     map[ "filename" ] = Vector3::ZERO;
 276     Image image = NewImage( map );
 277     tet_result( TET_FAIL );
 278   }
 279   catch ( DaliException& e )
 280   {
 281     DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
 282   }
 283
 284   // Invalid load-policy
 285   try
 286   {
 287     Property::Map map;
 288     map[ "load-policy" ] = Vector3::ZERO;
 289     Image image = NewImage( map );
 290     tet_result( TET_FAIL );
 291   }
 292   catch ( DaliException& e )
 293   {
 294     DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
 295
 296     // Invalid value
 297     try
 298     {
 299       Property::Map map;
 300       map[ "load-policy" ] = "INVALID";
 301       Image image = NewImage( map );
 302       tet_result( TET_FAIL );
 303     }
 304     catch ( DaliException& e )
 305     {
 306       DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
 307     }
 308   }
 309
 310   // Invalid release-policy
 311   try
 312   {
 313     Property::Map map;
 314     map[ "release-policy" ] = Vector3::ZERO;
 315     Image image = NewImage( map );
 316     tet_result( TET_FAIL );
 317   }
 318   catch ( DaliException& e )
 319   {
 320     DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
 321
 322     // Invalid value
 323     try
 324     {
 325       Property::Map map;
 326       map[ "release-policy" ] = "INVALID";
 327       Image image = NewImage( map );
 328       tet_result( TET_FAIL );
 329     }
 330     catch ( DaliException& e )
 331     {
 332       DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
 333     }
 334   }
 335
 336   // Invalid width
 337   try
 338   {
 339     Property::Map map;
 340     map[ "width" ] = "Invalid";
 341     map[ "height" ] = "Invalid";
 342     Image image = NewImage( map );
 343     tet_result( TET_FAIL );
 344   }
 345   catch ( DaliException& e )
 346   {
 347     DALI_TEST_ASSERT( e, "value.GetType()", TEST_LOCATION );
 348   }
 349
 350   // Invalid height
 351   try
 352   {
 353     Property::Map map;
 354     map[ "width" ] = 10;
 355     map[ "height" ] = "Invalid";
 356     Image image = NewImage( map );
 357     tet_result( TET_FAIL );
 358   }
 359   catch ( DaliException& e )
 360   {
 361     DALI_TEST_ASSERT( e, "value.GetType()", TEST_LOCATION );
 362   }
 363
 364   // Invalid pixel-format
 365   try
 366   {
 367     Property::Map map;
 368     map[ "pixel-format" ] = Vector3::ZERO;
 369     Image image = NewImage( map );
 370     tet_result( TET_FAIL );
 371   }
 372   catch ( DaliException& e )
 373   {
 374     DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
 375
 376     // Invalid value
 377     try
 378     {
 379       Property::Map map;
 380       map[ "pixel-format" ] = "INVALID";
 381       Image image = NewImage( map );
 382       tet_result( TET_FAIL );
 383     }
 384     catch ( DaliException& e )
 385     {
 386       DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
 387     }
 388   }
 389
 390   // Invalid scaling-mode
 391   try
 392   {
 393     Property::Map map;
 394     map[ "scaling-mode" ] = Vector3::ZERO;
 395     Image image = NewImage( map );
 396     tet_result( TET_FAIL );
 397   }
 398   catch ( DaliException& e )
 399   {
 400     DALI_TEST_ASSERT( e, "map.GetValue(field).GetType()", TEST_LOCATION );
 401
 402     // Invalid value
 403     try
 404     {
 405       Property::Map map;
 406       map[ "scaling-mode" ] = "INVALID";
 407       Image image = NewImage( map );
 408       tet_result( TET_FAIL );
 409     }
 410     catch ( DaliException& e )
 411     {
 412       DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
 413     }
 414   }
 415
 416   // Invalid type
 417   try
 418   {
 419     Property::Map map;
 420     map[ "type" ] = Vector3::ZERO;
 421     Image image = NewImage( map );
 422     tet_result( TET_FAIL );
 423   }
 424   catch ( DaliException& e )
 425   {
 426     DALI_TEST_ASSERT( e, "map.GetValue(\"type\").GetType()", TEST_LOCATION );
 427
 428     // Invalid value
 429     try
 430     {
 431       Property::Map map;
 432       map[ "type" ] = "INVALID";
 433       Image image = NewImage( map );
 434       tet_result( TET_FAIL );
 435     }
 436     catch ( DaliException& e )
 437     {
 438       DALI_TEST_ASSERT( e, "!\"Unknown", TEST_LOCATION );
 439     }
 440   }
 441   END_TEST;
 442 }
 443
 444
 445 int UtcDaliScriptingNewImage(void)
 446 {
 447   TestApplication application;
 448
 449   Property::Map map;
 450   map[ "filename" ] = "TEST_FILE";
 451
 452   // Filename only
 453   {
 454     ResourceImage image = ResourceImage::DownCast( NewImage( map ) );
 455     DALI_TEST_EQUALS( "TEST_FILE", image.GetUrl(), TEST_LOCATION );
 456   }
 457
 458   // load-policy
 459   map[ "load-policy" ] = "";
 460   {
 461     const StringEnum< int > values[] =
 462     {
 463         { "IMMEDIATE", ResourceImage::IMMEDIATE },
 464         { "ON_DEMAND", ResourceImage::ON_DEMAND }
 465     };
 466     TestEnumStrings< ResourceImage::LoadPolicy, ResourceImage >( map, values, ( sizeof( values ) / sizeof ( values[0] ) ), &ResourceImage::GetLoadPolicy, &NewResourceImage );
 467   }
 468
 469   // release-policy
 470   map[ "release-policy" ] = "";
 471   {
 472     const StringEnum< int > values[] =
 473     {
 474         { "UNUSED", Image::UNUSED },
 475         { "NEVER", Image::NEVER }
 476     };
 477     TestEnumStrings< Image::ReleasePolicy, Image >( map, values, ( sizeof( values ) / sizeof ( values[0] ) ), &Image::GetReleasePolicy, &NewImage );
 478   }
 479
 480   // float width and height
 481   map[ "width" ] = (float) 10.0f;
 482   map[ "height" ] = (float) 20.0f;
 483   {
 484     Image image = NewImage( map );
 485     DALI_TEST_EQUALS( image.GetWidth(), 10.0f, TEST_LOCATION );
 486     DALI_TEST_EQUALS( image.GetHeight(), 20.0f, TEST_LOCATION );
 487   }
 488
 489   // int width and height
 490   map[ "width"] = (int) 50;
 491   map[ "height" ] = (int) 70;
 492   {
 493     Image image = NewImage( map );
 494     DALI_TEST_EQUALS( image.GetWidth(), 50u, TEST_LOCATION );
 495     DALI_TEST_EQUALS( image.GetHeight(), 70u, TEST_LOCATION );
 496   }
 497
 498   //map.erase( map.end() - 2, map.end() );
 499
 500   // scaling-mode
 501   map[ "scaling-mode" ] = "";
 502   {
 503     const StringEnum< int > values[] =
 504     {
 505         { "SHRINK_TO_FIT", ImageAttributes::ShrinkToFit },
 506         { "SCALE_TO_FILL", ImageAttributes::ScaleToFill },
 507         { "FIT_WIDTH", ImageAttributes::FitWidth },
 508         { "FIT_HEIGHT", ImageAttributes::FitHeight },
 509     };
 510     TestEnumStrings< ImageAttributes::ScalingMode, ImageAttributes >( map, values, ( sizeof( values ) / sizeof ( values[0] ) ), &ImageAttributes::GetScalingMode, &NewImageAttributes );
 511   }
 512
 513   // type FrameBufferImage
 514   map[ "type" ] = "FrameBufferImage";
 515   {
 516     Image image = NewImage( map );
 517     DALI_TEST_CHECK( FrameBufferImage::DownCast( image ) );
 518   }
 519   // type BitMapImage
 520    map[ "type" ] = "BitmapImage";
 521    {
 522      Image image = NewImage( map );
 523      DALI_TEST_CHECK( BitmapImage::DownCast( image ) );
 524      DALI_TEST_CHECK((BitmapImage::DownCast( image )).GetPixelFormat()== Pixel::RGBA8888);
 525    }
 526
 527    // pixel-format
 528    map[ "pixel-format" ] = "";
 529    {
 530      const StringEnum< int > values[] =
 531      {
 532          { "A8", Pixel::A8 },
 533          { "L8", Pixel::L8 },
 534          { "LA88", Pixel::LA88 },
 535          { "RGB565", Pixel::RGB565 },
 536          { "BGR565", Pixel::BGR565 },
 537          { "RGBA4444", Pixel::RGBA4444 },
 538          { "BGRA4444", Pixel::BGRA4444 },
 539          { "RGBA5551", Pixel::RGBA5551 },
 540          { "BGRA5551", Pixel::BGRA5551 },
 541          { "RGB888", Pixel::RGB888 },
 542          { "RGB8888", Pixel::RGB8888 },
 543          { "BGR8888", Pixel::BGR8888 },
 544          { "RGBA8888", Pixel::RGBA8888 },
 545          { "BGRA8888", Pixel::BGRA8888 },
 546        /*{ "COMPRESSED_R11_EAC", Pixel::COMPRESSED_R11_EAC },
 547          { "COMPRESSED_SIGNED_R11_EAC", Pixel::COMPRESSED_SIGNED_R11_EAC },
 548          { "COMPRESSED_RG11_EAC", Pixel::COMPRESSED_RG11_EAC },
 549          { "COMPRESSED_SIGNED_RG11_EAC", Pixel::COMPRESSED_SIGNED_RG11_EAC },
 550          { "COMPRESSED_RGB8_ETC2", Pixel::COMPRESSED_RGB8_ETC2 },
 551          { "COMPRESSED_SRGB8_ETC2", Pixel::COMPRESSED_SRGB8_ETC2 },
 552          { "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2", Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 },
 553          { "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2", Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 },
 554          { "COMPRESSED_RGBA8_ETC2_EAC", Pixel::COMPRESSED_RGBA8_ETC2_EAC },
 555          { "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC", Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC },
 556          { "COMPRESSED_RGB8_ETC1", Pixel::COMPRESSED_RGB8_ETC1 },
 557          { "COMPRESSED_RGB_PVRTC_4BPPV1", Pixel::COMPRESSED_RGB_PVRTC_4BPPV1 },*/
 558          // BitmapImage doesnot support compressed format
 559      };
 560
 561      TestEnumStrings< Pixel::Format, BitmapImage >( map, values, ( sizeof( values ) / sizeof ( values[0] ) ), &BitmapImage::GetPixelFormat, &NewBitmapImage );
 562    }
 563
 564   // type Image
 565   map[ "type" ] = "Image";
 566   {
 567     Image image = NewImage( map );
 568     DALI_TEST_CHECK( ResourceImage::DownCast( image ) );
 569     DALI_TEST_CHECK( !FrameBufferImage::DownCast( image ) );
 570     DALI_TEST_CHECK( !BitmapImage::DownCast( image ) );
 571   }
 572   END_TEST;
 573 }
 574
 575 int UtcDaliScriptingNewShaderEffect(void)
 576 {
 577   TestApplication application;
 578
 579   Property::Map programMap;
 580   programMap[ "vertex-filename" ] = "bump.vert";
 581   programMap[ "fragment-filename" ] = "bump.frag";
 582
 583   Property::Map imageMap;
 584   imageMap[ "filename" ] = "image.png";
 585
 586   Property::Map map;
 587   map[ "image" ] = imageMap;
 588   map[ "program" ] = programMap;
 589   map[ "uLightPosition" ] = Vector3( 0.0, 0.0, -1.5);
 590   map[ "uAmbientLight" ] = (int)10;
 591
 592   ShaderEffect shader = NewShaderEffect( map );
 593
 594   DALI_TEST_CHECK( shader );
 595   END_TEST;
 596 }
 597
 598 int UtcDaliScriptingNewActorNegative(void)
 599 {
 600   TestApplication application;
 601
 602   // Empty map
 603   {
 604     Actor handle = NewActor( Property::Map() );
 605     DALI_TEST_CHECK( !handle );
 606   }
 607
 608   // Map with only properties
 609   {
 610     Property::Map map;
 611     map[ "parent-origin" ] = ParentOrigin::TOP_CENTER;
 612     map[ "anchor-point" ] = AnchorPoint::TOP_CENTER;
 613     Actor handle = NewActor( map );
 614     DALI_TEST_CHECK( !handle );
 615   }
 616
 617   // Add some signals to the map, we should have no signal connections as its not yet supported
 618   {
 619     Property::Map map;
 620     map[ "type" ] = "Actor";
 621     map[ "signals" ] = Property::MAP;
 622     Actor handle = NewActor( map );
 623     DALI_TEST_CHECK( handle );
 624     DALI_TEST_CHECK( !handle.MouseWheelEventSignal().GetConnectionCount() );
 625     DALI_TEST_CHECK( !handle.OffStageSignal().GetConnectionCount() );
 626     DALI_TEST_CHECK( !handle.OnStageSignal().GetConnectionCount() );
 627     DALI_TEST_CHECK( !handle.TouchedSignal().GetConnectionCount() );
 628   }
 629   END_TEST;
 630 }
 631
 632 int UtcDaliScriptingNewActorProperties(void)
 633 {
 634   TestApplication application;
 635
 636   Property::Map map;
 637   map[ "type" ] = "Actor";
 638   map[ "size" ] = Vector3::ONE;
 639   map[ "position" ] = Vector3::XAXIS;
 640   map[ "scale" ] = Vector3::ONE;
 641   map[ "visible" ] = false;
 642   map[ "color" ] = Color::MAGENTA;
 643   map[ "name" ] = "MyActor";
 644   map[ "color-mode" ] = "USE_PARENT_COLOR";
 645   map[ "inherit-shader-effect" ] = false;
 646   map[ "sensitive" ] = false;
 647   map[ "leave-required" ] = true;
 648   map[ "position-inheritance" ] = "DONT_INHERIT_POSITION";
 649   map[ "draw-mode" ] = "STENCIL";
 650   map[ "inherit-rotation" ] = false;
 651   map[ "inherit-scale" ] = false;
 652
 653   // Default properties
 654   {
 655     Actor handle = NewActor( map );
 656     DALI_TEST_CHECK( handle );
 657
 658     Stage::GetCurrent().Add( handle );
 659     application.SendNotification();
 660     application.Render();
 661
 662     DALI_TEST_EQUALS( handle.GetCurrentSize(), Vector3::ONE, TEST_LOCATION );
 663     DALI_TEST_EQUALS( handle.GetCurrentPosition(), Vector3::XAXIS, TEST_LOCATION );
 664     DALI_TEST_EQUALS( handle.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
 665     DALI_TEST_EQUALS( handle.IsVisible(), false, TEST_LOCATION );
 666     DALI_TEST_EQUALS( handle.GetCurrentColor(), Color::MAGENTA, TEST_LOCATION );
 667     DALI_TEST_EQUALS( handle.GetName(), "MyActor", TEST_LOCATION );
 668     DALI_TEST_EQUALS( handle.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
 669     DALI_TEST_EQUALS( handle.IsSensitive(), false, TEST_LOCATION );
 670     DALI_TEST_EQUALS( handle.GetLeaveRequired(), true, TEST_LOCATION );
 671     DALI_TEST_EQUALS( handle.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
 672     DALI_TEST_EQUALS( handle.GetDrawMode(), DrawMode::STENCIL, TEST_LOCATION );
 673     DALI_TEST_EQUALS( handle.IsRotationInherited(), false, TEST_LOCATION );
 674     DALI_TEST_EQUALS( handle.IsScaleInherited(), false, TEST_LOCATION );
 675
 676     Stage::GetCurrent().Remove( handle );
 677   }
 678
 679   // Check Anchor point and parent origin vector3s
 680   map[ "parent-origin" ] = ParentOrigin::TOP_CENTER;
 681   map[ "anchor-point" ] = AnchorPoint::TOP_LEFT;
 682   {
 683     Actor handle = NewActor( map );
 684     DALI_TEST_CHECK( handle );
 685
 686     Stage::GetCurrent().Add( handle );
 687     application.SendNotification();
 688     application.Render();
 689
 690     DALI_TEST_EQUALS( handle.GetCurrentParentOrigin(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
 691     DALI_TEST_EQUALS( handle.GetCurrentAnchorPoint(), AnchorPoint::TOP_LEFT, TEST_LOCATION );
 692
 693     Stage::GetCurrent().Remove( handle );
 694   }
 695
 696   // Check Anchor point and parent origin STRINGS
 697   map[ "parent-origin" ] = "BACK_TOP_LEFT";
 698   map[ "anchor-point" ] = "FRONT_CENTER_LEFT";
 699   {
 700     Actor handle = NewActor( map );
 701     DALI_TEST_CHECK( handle );
 702
 703     Stage::GetCurrent().Add( handle );
 704     application.SendNotification();
 705     application.Render();
 706
 707     DALI_TEST_EQUALS( handle.GetCurrentParentOrigin(), ParentOrigin::BACK_TOP_LEFT, TEST_LOCATION );
 708     DALI_TEST_EQUALS( handle.GetCurrentAnchorPoint(), AnchorPoint::FRONT_CENTER_LEFT, TEST_LOCATION );
 709
 710     Stage::GetCurrent().Remove( handle );
 711   }
 712   END_TEST;
 713 }
 714
 715 int UtcDaliScriptingNewActorChildren(void)
 716 {
 717   TestApplication application;
 718
 719   Property::Map map;
 720   map[ "type" ] = "Actor";
 721   map[ "position" ] = Vector3::XAXIS;
 722
 723   Property::Map child1Map;
 724   child1Map[ "type" ] = "ImageActor";
 725   child1Map[ "position" ] = Vector3::YAXIS;
 726
 727   Property::Map child2Map;
 728   child2Map[ "type" ] = "TextActor";
 729   child2Map[ "position" ] = Vector3::ZAXIS;
 730
 731   Property::Map grandChildMap;
 732   grandChildMap[ "type" ] = "LightActor";
 733   grandChildMap[ "position" ] = Vector3::ONE;
 734
 735   // Add arrays to appropriate maps
 736   Property::Array grandChildArray;
 737   grandChildArray.push_back( grandChildMap );
 738   Property::Array childArray;
 739   child1Map[ "actors" ] = grandChildArray;
 740   childArray.push_back( child1Map );
 741   childArray.push_back( child2Map );
 742   map[ "actors" ] = childArray;
 743
 744   // Create
 745   Actor handle = NewActor( map );
 746   DALI_TEST_CHECK( handle );
 747
 748   Stage::GetCurrent().Add( handle );
 749   application.SendNotification();
 750   application.Render();
 751
 752   DALI_TEST_EQUALS( handle.GetCurrentPosition(), Vector3::XAXIS, TEST_LOCATION );
 753   DALI_TEST_EQUALS( handle.GetChildCount(), 2u, TEST_LOCATION );
 754
 755   Actor child1 = handle.GetChildAt(0);
 756   DALI_TEST_CHECK( child1 );
 757   DALI_TEST_CHECK( ImageActor::DownCast( child1 ) );
 758   DALI_TEST_EQUALS( child1.GetCurrentPosition(), Vector3::YAXIS, TEST_LOCATION );
 759   DALI_TEST_EQUALS( child1.GetChildCount(), 1u, TEST_LOCATION );
 760
 761   Actor grandChild = child1.GetChildAt( 0 );
 762   DALI_TEST_CHECK( grandChild );
 763   DALI_TEST_CHECK( LightActor::DownCast( grandChild ) );
 764   DALI_TEST_EQUALS( grandChild.GetCurrentPosition(), Vector3::ONE, TEST_LOCATION );
 765   DALI_TEST_EQUALS( grandChild.GetChildCount(), 0u, TEST_LOCATION );
 766
 767   Stage::GetCurrent().Remove( handle );
 768   END_TEST;
 769 }
 770
 771
 772 int UtcDaliScriptingCreatePropertyMapActor(void)
 773 {
 774   TestApplication application;
 775
 776   // Actor Type
 777   {
 778     Actor actor = Actor::New();
 779
 780     Property::Map map;
 781     CreatePropertyMap( actor, map );
 782     DALI_TEST_CHECK( !map.Empty() );
 783     Property::Value value( map );
 784     DALI_TEST_CHECK( value.HasKey( "type" ) );
 785     DALI_TEST_EQUALS( value.GetValue( "type").Get< std::string >(), "Actor", TEST_LOCATION );
 786
 787     Stage::GetCurrent().Remove( actor );
 788   }
 789
 790   // ImageActor Type
 791   {
 792     Actor actor = ImageActor::New();
 793
 794     Property::Map map;
 795     CreatePropertyMap( actor, map );
 796     DALI_TEST_CHECK( !map.Empty() );
 797     Property::Value value( map );
 798     DALI_TEST_CHECK( value.HasKey( "type" ) );
 799     DALI_TEST_EQUALS( value.GetValue( "type").Get< std::string >(), "ImageActor", TEST_LOCATION );
 800
 801     Stage::GetCurrent().Remove( actor );
 802   }
 803
 804   // Default properties
 805   {
 806     Actor actor = Actor::New();
 807     actor.SetSize( Vector3::ONE );
 808     actor.SetPosition( Vector3::XAXIS );
 809     actor.SetScale( Vector3::ZAXIS );
 810     actor.SetVisible( false );
 811     actor.SetColor( Color::MAGENTA );
 812     actor.SetName( "MyActor" );
 813     actor.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 814     actor.SetParentOrigin( ParentOrigin::TOP_RIGHT );
 815     actor.SetSensitive( false );
 816     actor.SetLeaveRequired( true );
 817     actor.SetInheritRotation( false );
 818     actor.SetInheritScale( false );
 819     actor.SetSizeMode( USE_OWN_SIZE );
 820     actor.SetSizeModeFactor( Vector3::ONE );
 821
 822     Stage::GetCurrent().Add( actor );
 823     application.SendNotification();
 824     application.Render();
 825
 826     Property::Map map;
 827     CreatePropertyMap( actor, map );
 828
 829     DALI_TEST_CHECK( !map.Empty() );
 830     Property::Value value( map );
 831     DALI_TEST_CHECK( value.HasKey( "size" ) );
 832     DALI_TEST_EQUALS( value.GetValue( "size" ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
 833     DALI_TEST_CHECK( value.HasKey( "position" ) );
 834     DALI_TEST_EQUALS( value.GetValue( "position" ).Get< Vector3 >(), Vector3::XAXIS, TEST_LOCATION );
 835     DALI_TEST_CHECK( value.HasKey( "scale" ) );
 836     DALI_TEST_EQUALS( value.GetValue( "scale" ).Get< Vector3 >(), Vector3::ZAXIS, TEST_LOCATION );
 837     DALI_TEST_CHECK( value.HasKey( "visible" ) );
 838     DALI_TEST_EQUALS( value.GetValue( "visible" ).Get< bool >(), false, TEST_LOCATION );
 839     DALI_TEST_CHECK( value.HasKey( "color" ) );
 840     DALI_TEST_EQUALS( value.GetValue( "color" ).Get< Vector4 >(), Color::MAGENTA, TEST_LOCATION );
 841     DALI_TEST_CHECK( value.HasKey( "name" ) );
 842     DALI_TEST_EQUALS( value.GetValue( "name").Get< std::string >(), "MyActor", TEST_LOCATION );
 843     DALI_TEST_CHECK( value.HasKey( "anchor-point" ) );
 844     DALI_TEST_EQUALS( value.GetValue( "anchor-point" ).Get< Vector3 >(), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
 845     DALI_TEST_CHECK( value.HasKey( "parent-origin" ) );
 846     DALI_TEST_EQUALS( value.GetValue( "parent-origin" ).Get< Vector3 >(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
 847     DALI_TEST_CHECK( value.HasKey( "sensitive" ) );
 848     DALI_TEST_EQUALS( value.GetValue( "sensitive" ).Get< bool >(), false, TEST_LOCATION );
 849     DALI_TEST_CHECK( value.HasKey( "leave-required" ) );
 850     DALI_TEST_EQUALS( value.GetValue( "leave-required" ).Get< bool >(), true, TEST_LOCATION );
 851     DALI_TEST_CHECK( value.HasKey( "inherit-rotation" ) );
 852     DALI_TEST_EQUALS( value.GetValue( "inherit-rotation" ).Get< bool >(), false, TEST_LOCATION );
 853     DALI_TEST_CHECK( value.HasKey( "inherit-scale" ) );
 854     DALI_TEST_EQUALS( value.GetValue( "inherit-scale" ).Get< bool >(), false, TEST_LOCATION );
 855     DALI_TEST_CHECK( value.HasKey( "size-mode-factor" ) );
 856     DALI_TEST_EQUALS( value.GetValue( "size-mode-factor" ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
 857
 858     Stage::GetCurrent().Remove( actor );
 859   }
 860
 861   // ColorMode
 862   TestEnumStrings< ColorMode >( "color-mode", application, COLOR_MODE_VALUES, COLOR_MODE_VALUES_COUNT, &Actor::SetColorMode );
 863
 864   // PositionInheritanceMode
 865   TestEnumStrings< PositionInheritanceMode >( "position-inheritance", application, POSITION_INHERITANCE_MODE_VALUES, POSITION_INHERITANCE_MODE_VALUES_COUNT, &Actor::SetPositionInheritanceMode );
 866
 867   // DrawMode
 868   TestEnumStrings< DrawMode::Type >( "draw-mode", application, DRAW_MODE_VALUES, DRAW_MODE_VALUES_COUNT, &Actor::SetDrawMode );
 869
 870   // Children
 871   {
 872     Actor actor = Actor::New();
 873     Actor child = ImageActor::New();
 874     Actor grandChild = LightActor::New();
 875     actor.Add( child );
 876     child.Add( grandChild );
 877
 878     Stage::GetCurrent().Add( actor );
 879     application.SendNotification();
 880     application.Render();
 881
 882     Property::Map map;
 883     CreatePropertyMap( actor, map );
 884     DALI_TEST_CHECK( !map.Empty() );
 885
 886     Property::Value value( map );
 887     DALI_TEST_CHECK( value.HasKey( "type" ) );
 888     DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "Actor", TEST_LOCATION );
 889
 890     DALI_TEST_CHECK( value.HasKey( "actors" ) );
 891     Property::Array children( value.GetValue( "actors").Get< Property::Array >() );
 892     DALI_TEST_CHECK( !children.empty() );
 893     Property::Map childMap( children[0].Get< Property::Map >() );
 894     DALI_TEST_CHECK( !childMap.Empty() );
 895     Property::Value childValue( childMap );
 896     DALI_TEST_CHECK( childValue.HasKey( "type" ) );
 897     DALI_TEST_EQUALS( childValue.GetValue( "type" ).Get< std::string >(), "ImageActor", TEST_LOCATION );
 898
 899     DALI_TEST_CHECK( childValue.HasKey( "actors" ) );
 900     Property::Array grandChildren( childValue.GetValue( "actors").Get< Property::Array >() );
 901     DALI_TEST_CHECK( grandChildren.size() == 1u );
 902
 903     Property::Map grandChildMap( grandChildren[0].Get< Property::Map >() );
 904     DALI_TEST_CHECK( !grandChildMap.Empty() );
 905     Property::Value grandChildValue( grandChildMap );
 906     DALI_TEST_CHECK( grandChildValue.HasKey( "type" ) );
 907     DALI_TEST_EQUALS( grandChildValue.GetValue( "type" ).Get< std::string >(), "LightActor", TEST_LOCATION );
 908
 909     Stage::GetCurrent().Remove( actor );
 910   }
 911   END_TEST;
 912 }
 913
 914 int UtcDaliScriptingCreatePropertyMapImage(void)
 915 {
 916   TestApplication application;
 917
 918   // Empty
 919   {
 920     Image image;
 921     Property::Map map;
 922     CreatePropertyMap( image, map );
 923     DALI_TEST_CHECK( map.Empty() );
 924   }
 925
 926   // Default
 927   {
 928     Image image = ResourceImage::New( "MY_PATH" );
 929
 930     Property::Map map;
 931     CreatePropertyMap( image, map );
 932     DALI_TEST_CHECK( !map.Empty() );
 933
 934     Property::Value value( map );
 935     DALI_TEST_CHECK( value.HasKey( "type" ) );
 936     DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "ResourceImage", TEST_LOCATION );
 937     DALI_TEST_CHECK( value.HasKey( "filename" ) );
 938     DALI_TEST_EQUALS( value.GetValue( "filename" ).Get< std::string >(), "MY_PATH", TEST_LOCATION );
 939     DALI_TEST_CHECK( value.HasKey( "load-policy") );
 940     DALI_TEST_EQUALS( value.GetValue( "load-policy" ).Get< std::string >(), "IMMEDIATE", TEST_LOCATION );
 941     DALI_TEST_CHECK( value.HasKey( "release-policy") );
 942     DALI_TEST_EQUALS( value.GetValue( "release-policy" ).Get< std::string >(), "NEVER", TEST_LOCATION );
 943     DALI_TEST_CHECK( value.HasKey( "scaling-mode") );
 944     DALI_TEST_EQUALS( value.GetValue( "scaling-mode" ).Get< std::string >(), "SHRINK_TO_FIT", TEST_LOCATION );
 945     DALI_TEST_CHECK( !value.HasKey( "width" ) );
 946     DALI_TEST_CHECK( !value.HasKey( "height" ) );
 947   }
 948
 949   // Change values
 950   {
 951     ImageAttributes attributes;
 952     attributes.SetScalingMode( ImageAttributes::FitWidth );
 953     attributes.SetSize( 300, 400 );
 954     Image image = ResourceImage::New( "MY_PATH", attributes, ResourceImage::ON_DEMAND, Image::UNUSED );
 955
 956     Property::Map map;
 957     CreatePropertyMap( image, map );
 958     DALI_TEST_CHECK( !map.Empty() );
 959
 960     Property::Value value( map );
 961     DALI_TEST_CHECK( value.HasKey( "type" ) );
 962     DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "ResourceImage", TEST_LOCATION );
 963     DALI_TEST_CHECK( value.HasKey( "filename" ) );
 964     DALI_TEST_EQUALS( value.GetValue( "filename" ).Get< std::string >(), "MY_PATH", TEST_LOCATION );
 965     DALI_TEST_CHECK( value.HasKey( "load-policy") );
 966     DALI_TEST_EQUALS( value.GetValue( "load-policy" ).Get< std::string >(), "ON_DEMAND", TEST_LOCATION );
 967     DALI_TEST_CHECK( value.HasKey( "release-policy") );
 968     DALI_TEST_EQUALS( value.GetValue( "release-policy" ).Get< std::string >(), "UNUSED", TEST_LOCATION );
 969     DALI_TEST_CHECK( value.HasKey( "scaling-mode") );
 970     DALI_TEST_EQUALS( value.GetValue( "scaling-mode" ).Get< std::string >(), "FIT_WIDTH", TEST_LOCATION );
 971     DALI_TEST_CHECK( value.HasKey( "width" ) );
 972     DALI_TEST_EQUALS( value.GetValue( "width" ).Get< int >(), 300, TEST_LOCATION );
 973     DALI_TEST_CHECK( value.HasKey( "height" ) );
 974     DALI_TEST_EQUALS( value.GetValue( "height" ).Get< int >(), 400, TEST_LOCATION );
 975   }
 976
 977   // BitmapImage
 978   {
 979     Image image = BitmapImage::New( 200, 300, Pixel::A8 );
 980     Property::Map map;
 981     CreatePropertyMap( image, map );
 982     Property::Value value( map );
 983     DALI_TEST_CHECK( value.HasKey( "type" ) );
 984     DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "BitmapImage", TEST_LOCATION );
 985     DALI_TEST_CHECK( value.HasKey( "pixel-format") );
 986     DALI_TEST_EQUALS( value.GetValue( "pixel-format" ).Get< std::string >(), "A8", TEST_LOCATION );
 987   }
 988
 989   // FrameBufferImage
 990   {
 991     Image image = FrameBufferImage::New( 200, 300, Pixel::RGBA8888 );
 992     Property::Map map;
 993     CreatePropertyMap( image, map );
 994     Property::Value value( map );
 995     DALI_TEST_CHECK( value.HasKey( "type" ) );
 996     DALI_TEST_EQUALS( value.GetValue( "type" ).Get< std::string >(), "FrameBufferImage", TEST_LOCATION );
 997   }
 998   END_TEST;
 999 }
1000
1001 int UtcDaliScriptingGetEnumerationTemplates(void)
1002 {
1003   TestApplication application;
1004
1005   const Scripting::StringEnum< int > myTable[] =
1006   {
1007     { "ONE",    1 },
1008     { "TWO",    2 },
1009     { "THREE",  3 },
1010     { "FOUR",   4 },
1011     { "FIVE",   5 },
1012   };
1013   const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
1014
1015   for ( unsigned int i = 0; i < myTableCount; ++i )
1016   {
1017     tet_printf("Checking: %s\n", myTable[ i ].string );
1018     DALI_TEST_EQUALS( myTable[ i ].value, GetEnumeration( myTable[ i ].string, myTable, myTableCount ), TEST_LOCATION );
1019   }
1020
1021   for ( unsigned int i = 0; i < myTableCount; ++i )
1022   {
1023     tet_printf("Checking: %d\n", myTable[ i ].value );
1024     DALI_TEST_EQUALS( myTable[ i ].string, GetEnumerationName( myTable[ i ].value, myTable, myTableCount ), TEST_LOCATION );
1025   }
1026
1027   END_TEST;
1028 }
1029
1030 int UtcDaliScriptingCompareEnums(void)
1031 {
1032   // EQUAL
1033   DALI_TEST_CHECK( CompareEnums( "", "" ) );
1034   DALI_TEST_CHECK( CompareEnums( "HELLO", "HELLO" ) );
1035   DALI_TEST_CHECK( CompareEnums( "HELLO", "hello" ) );
1036   DALI_TEST_CHECK( CompareEnums( "hello", "HELLO" ) );
1037   DALI_TEST_CHECK( CompareEnums( "hello-world", "HELLO_WORLD" ) );
1038   DALI_TEST_CHECK( CompareEnums( "hello_WORLD", "HELLO-world" ) );
1039   DALI_TEST_CHECK( CompareEnums( "hello_WORLD-", "HELLO-world_" ) );
1040   DALI_TEST_CHECK( CompareEnums( "_hello_WORLD-", "-HELLO-world_" ) );
1041   DALI_TEST_CHECK( CompareEnums( "-hello_WORLD-", "_HELLO-world_" ) );
1042   DALI_TEST_CHECK( CompareEnums( "hello123", "HELLO123" ) );
1043
1044   // NOT EQUAL
1045   DALI_TEST_CHECK( ! CompareEnums( "hello", "HELLOWORLD" ) );
1046
1047   END_TEST;
1048 }