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

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