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