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