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