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