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