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/devel-api/scripting/scripting.h>
  23 #include <dali-test-suite-utils.h>
  24
  25 using namespace Dali;
  26 using namespace Dali::Scripting;
  27
  28 namespace
  29 {
  30
  31 const StringEnum COLOR_MODE_VALUES[] =
  32 {
  33     { "USE_OWN_COLOR", USE_OWN_COLOR },
  34     { "USE_PARENT_COLOR", USE_PARENT_COLOR },
  35     { "USE_OWN_MULTIPLY_PARENT_COLOR", USE_OWN_MULTIPLY_PARENT_COLOR },
  36     { "USE_OWN_MULTIPLY_PARENT_ALPHA", USE_OWN_MULTIPLY_PARENT_ALPHA },
  37 };
  38 const unsigned int COLOR_MODE_VALUES_COUNT = sizeof( COLOR_MODE_VALUES ) / sizeof( COLOR_MODE_VALUES[0] );
  39
  40 const StringEnum POSITION_INHERITANCE_MODE_VALUES[] =
  41 {
  42     { "INHERIT_PARENT_POSITION", INHERIT_PARENT_POSITION },
  43     { "USE_PARENT_POSITION", USE_PARENT_POSITION },
  44     { "USE_PARENT_POSITION_PLUS_LOCAL_POSITION", USE_PARENT_POSITION_PLUS_LOCAL_POSITION },
  45     { "DONT_INHERIT_POSITION", DONT_INHERIT_POSITION },
  46 };
  47 const unsigned int POSITION_INHERITANCE_MODE_VALUES_COUNT = sizeof( POSITION_INHERITANCE_MODE_VALUES ) / sizeof( POSITION_INHERITANCE_MODE_VALUES[0] );
  48
  49 const StringEnum DRAW_MODE_VALUES[] =
  50 {
  51     { "NORMAL", DrawMode::NORMAL },
  52     { "OVERLAY_2D", DrawMode::OVERLAY_2D },
  53     { "STENCIL", DrawMode::STENCIL },
  54 };
  55 const unsigned int DRAW_MODE_VALUES_COUNT = sizeof( DRAW_MODE_VALUES ) / sizeof( DRAW_MODE_VALUES[0] );
  56
  57
  58 ////////////////////////////////////////////////////////////////////////////////
  59 // Helpers for string to enum comparisons for Image and Image loading parameters
  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 char * const keyName,               // the name of the key to iterate through
  69   const StringEnum* values,                 // An array of string values
  70   unsigned int num,                         // Number of items in the array
  71   T ( X::*method )() const,                 // The member method of X to call to get the enum
  72   X ( *creator ) ( const Property::Value& ) // The method which creates an instance of type X
  73 )
  74 {
  75   // get the key reference so we can change its value
  76   Property::Value* value = map.Find( keyName );
  77   for ( unsigned int i = 0; i < num; ++i )
  78   {
  79     *value = values[i].string;
  80     tet_printf("Checking: %s: %s\n", keyName, values[i].string );
  81     X instance = creator( map );
  82     DALI_TEST_EQUALS( values[i].value, (int)( 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* 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( 0 < map.Count() );
 131     DALI_TEST_CHECK( NULL != map.Find( keyName ) );
 132     DALI_TEST_EQUALS( map.Find( keyName )->Get< std::string >(), values[i].string, TEST_LOCATION );
 133
 134     Stage::GetCurrent().Remove( actor );
 135   }
 136 }
 137
 138 //////////////////////////////////////////////////////////////////////////////
 139
 140
 141 } // anon namespace
 142
 143 int UtcDaliScriptingNewImageNegative01(void)
 144 {
 145   // Invalid filename
 146   Property::Map map;
 147   map[ "filename" ] = Vector3::ZERO;
 148   // will give us an empty image handle
 149   Image image = NewImage( map );
 150   DALI_TEST_CHECK( !image );
 151   END_TEST;
 152 }
 153
 154 int UtcDaliScriptingNewImageNegative02(void)
 155 {
 156   TestApplication application; // Image needs application
 157   // Invalid load-policy value type
 158   Property::Map map;
 159   map[ "filename" ] = "TEST_FILE";
 160   map[ "loadPolicy" ] = Vector3::ZERO;
 161   // will give us a valid image handle with default load policy
 162   Image image = NewImage( map );
 163   DALI_TEST_CHECK( image );
 164   ResourceImage resImage = ResourceImage::DownCast( image );
 165   DALI_TEST_CHECK( resImage );
 166   DALI_TEST_EQUALS( resImage.GetLoadPolicy(), ResourceImage::IMMEDIATE, TEST_LOCATION );
 167   END_TEST;
 168 }
 169
 170 int UtcDaliScriptingNewImageNegative03(void)
 171 {
 172   TestApplication application; // Image needs application
 173   // Invalid load-policy value
 174   Property::Map map;
 175   map[ "filename" ] = "TEST_FILE";
 176   map[ "loadPolicy" ] = "INVALID";
 177   // will give us a valid image with default load policy
 178   Image image = NewImage( map );
 179   DALI_TEST_CHECK( image );
 180   ResourceImage resImage = ResourceImage::DownCast( image );
 181   DALI_TEST_CHECK( resImage );
 182   DALI_TEST_EQUALS( resImage.GetLoadPolicy(), ResourceImage::IMMEDIATE, TEST_LOCATION );
 183   END_TEST;
 184 }
 185
 186 int UtcDaliScriptingNewImageNegative04(void)
 187 {
 188   TestApplication application; // Image needs application
 189   // Invalid release-policy value type
 190   Property::Map map;
 191   map[ "filename" ] = "TEST_FILE";
 192   map[ "releasePolicy" ] = Vector3::ZERO;
 193   // will give us a valid image with default release policy
 194   Image image = NewImage( map );
 195   DALI_TEST_CHECK( image );
 196   ResourceImage resImage = ResourceImage::DownCast( image );
 197   DALI_TEST_CHECK( resImage );
 198   DALI_TEST_EQUALS( resImage.GetReleasePolicy(), Image::NEVER, TEST_LOCATION );
 199   END_TEST;
 200 }
 201
 202 int UtcDaliScriptingNewImageNegative05(void)
 203 {
 204   TestApplication application; // Image needs application
 205   // Invalid release-policy value
 206   Property::Map map;
 207   map[ "filename" ] = "TEST_FILE";
 208   map[ "releasePolicy" ] = "INVALID";
 209   // will give us a valid image with default release policy
 210   Image image = NewImage( map );
 211   DALI_TEST_CHECK( image );
 212   ResourceImage resImage = ResourceImage::DownCast( image );
 213   DALI_TEST_CHECK( resImage );
 214   DALI_TEST_EQUALS( resImage.GetReleasePolicy(), Image::NEVER, TEST_LOCATION );
 215   END_TEST;
 216 }
 217
 218 int UtcDaliScriptingNewImageNegative06(void)
 219 {
 220   TestApplication application; // Image needs application
 221   // Invalid width and height
 222   Property::Map map;
 223   map[ "filename" ] = "TEST_FILE";
 224   map[ "width" ] = "Invalid";
 225   map[ "height" ] = 100;
 226   // will give us a valid image
 227   Image image = NewImage( map );
 228   DALI_TEST_CHECK( image );
 229   ResourceImage resImage = ResourceImage::DownCast( image );
 230   DALI_TEST_CHECK( resImage );
 231   DALI_TEST_EQUALS( resImage.GetWidth(), 0u, TEST_LOCATION );
 232   DALI_TEST_EQUALS( resImage.GetHeight(), 100u, TEST_LOCATION );
 233   END_TEST;
 234 }
 235
 236 int UtcDaliScriptingNewImageNegative07(void)
 237 {
 238   TestApplication application; // Image needs application
 239   // Invalid height
 240   Property::Map map;
 241   map[ "filename" ] = "TEST_FILE";
 242   map[ "width" ] = 10;
 243   map[ "height" ] = "Invalid";
 244   // will give us a valid image
 245   Image image = NewImage( map );
 246   DALI_TEST_CHECK( image );
 247   ResourceImage resImage = ResourceImage::DownCast( image );
 248   DALI_TEST_CHECK( resImage );
 249   DALI_TEST_EQUALS( resImage.GetWidth(), 10u, TEST_LOCATION );
 250   DALI_TEST_EQUALS( resImage.GetHeight(), 0u, TEST_LOCATION );
 251   END_TEST;
 252 }
 253
 254 int UtcDaliScriptingNewImageNegative08(void)
 255 {
 256   TestApplication application; // Image needs application
 257   // Invalid fitting-mode
 258   Property::Map map;
 259   map[ "filename" ] = "TEST_FILE";
 260   map[ "fittingMode" ] = Vector3::ZERO;
 261   // will give us a valid image
 262   Image image = NewImage( map );
 263   DALI_TEST_CHECK( image );
 264   ResourceImage resImage = ResourceImage::DownCast( image );
 265   DALI_TEST_CHECK( resImage );
 266   END_TEST;
 267 }
 268
 269 int UtcDaliScriptingNewImageNegative09(void)
 270 {
 271   TestApplication application; // Image needs application
 272   // Invalid value
 273   Property::Map map;
 274   map[ "filename" ] = "TEST_FILE";
 275   map[ "fittingMode" ] = "INVALID";
 276   // will give us a valid image
 277   Image image = NewImage( map );
 278   DALI_TEST_CHECK( image );
 279   ResourceImage resImage = ResourceImage::DownCast( image );
 280   DALI_TEST_CHECK( resImage );
 281   END_TEST;
 282 }
 283
 284 int UtcDaliScriptingNewImageNegative10(void)
 285 {
 286   TestApplication application; // Image needs application
 287   // Invalid scaling-mode
 288   Property::Map map;
 289   map[ "filename" ] = "TEST_FILE";
 290   map[ "samplingMode" ] = Vector3::ZERO;
 291   // will give us a valid image
 292   Image image = NewImage( map );
 293   DALI_TEST_CHECK( image );
 294   ResourceImage resImage = ResourceImage::DownCast( image );
 295   DALI_TEST_CHECK( resImage );
 296   END_TEST;
 297 }
 298
 299 int UtcDaliScriptingNewImageNegative12(void)
 300 {
 301   TestApplication application; // Image needs application
 302   // Invalid orientation-correction
 303   Property::Map map;
 304   map[ "filename" ] = "TEST_FILE";
 305   map[ "orientation" ] = Vector3::ZERO;
 306   // will give us a valid image
 307   Image image = NewImage( map );
 308   DALI_TEST_CHECK( image );
 309   ResourceImage resImage = ResourceImage::DownCast( image );
 310   DALI_TEST_CHECK( resImage );
 311   END_TEST;
 312 }
 313
 314 int UtcDaliScriptingNewImageNegative13(void)
 315 {
 316   TestApplication application; // Image needs application
 317   // Invalid type
 318   Property::Map map;
 319   map[ "filename" ] = "TEST_FILE";
 320   map[ "type" ] = Vector3::ZERO;
 321   // will give us a valid image
 322   Image image = NewImage( map );
 323   DALI_TEST_CHECK( image );
 324   ResourceImage resImage = ResourceImage::DownCast( image );
 325   DALI_TEST_CHECK( resImage );
 326   END_TEST;
 327 }
 328
 329 int UtcDaliScriptingNewImageNegative14(void)
 330 {
 331   // Invalid value
 332   Property::Map map;
 333   map[ "type" ] = "INVALID";
 334   Image image = NewImage( map );
 335   DALI_TEST_CHECK( !image );
 336   END_TEST;
 337 }
 338
 339 int UtcDaliScriptingNewImageNegative15(void)
 340 {
 341   // Invalid pixel-format
 342   Property::Map map;
 343   map[ "pixelFormat" ] = Vector3::ZERO;
 344   Image image = NewImage( map );
 345   DALI_TEST_CHECK( !image );
 346   END_TEST;
 347 }
 348
 349 int UtcDaliScriptingNewImageNegative16(void)
 350 {
 351   // Invalid value
 352   Property::Map map;
 353   map[ "pixelFormat" ] = "INVALID";
 354   Image image = NewImage( map );
 355   DALI_TEST_CHECK( !image );
 356   END_TEST;
 357 }
 358
 359 int UtcDaliScriptingNewImage01P(void)
 360 {
 361   TestApplication application; // Image needs application
 362
 363   Property::Map map;
 364   map[ "filename" ] = "TEST_FILE";
 365
 366   // Filename only
 367   ResourceImage image = ResourceImage::DownCast( NewImage( map ) );
 368   DALI_TEST_EQUALS( "TEST_FILE", image.GetUrl(), TEST_LOCATION );
 369   END_TEST;
 370 }
 371
 372 int UtcDaliScriptingNewImage02P(void)
 373 {
 374   TestApplication application;
 375
 376   Property::Map map;
 377   map[ "filename" ] = "TEST_FILE";
 378
 379   // load-policy
 380   map[ "loadPolicy" ] = "";
 381   const StringEnum values[] =
 382   {
 383     { "IMMEDIATE", ResourceImage::IMMEDIATE },
 384     { "ON_DEMAND", ResourceImage::ON_DEMAND }
 385   };
 386   TestEnumStrings< ResourceImage::LoadPolicy, ResourceImage >( map, "loadPolicy",  values, ( sizeof( values ) / sizeof ( values[0] ) ), &ResourceImage::GetLoadPolicy, &NewResourceImage );
 387   END_TEST;
 388 }
 389
 390 int UtcDaliScriptingNewImage03P(void)
 391 {
 392   TestApplication application;
 393
 394   Property::Map map;
 395   map[ "filename" ] = "TEST_FILE";
 396
 397   // release-policy
 398   map[ "releasePolicy" ] = "";
 399   const StringEnum values[] =
 400   {
 401     { "UNUSED", Image::UNUSED },
 402     { "NEVER", Image::NEVER }
 403   };
 404   TestEnumStrings< Image::ReleasePolicy, Image >( map, "releasePolicy",  values, ( sizeof( values ) / sizeof ( values[0] ) ), &Image::GetReleasePolicy, &NewImage );
 405   END_TEST;
 406 }
 407
 408 int UtcDaliScriptingNewImage04P(void)
 409 {
 410   TestApplication application;
 411
 412   Property::Map map;
 413   map[ "filename" ] = "TEST_FILE";
 414
 415   // float width and height
 416   map[ "width" ] = (float) 10.0f;
 417   map[ "height" ] = (float) 20.0f;
 418   Image image = NewImage( map );
 419   DALI_TEST_EQUALS( image.GetWidth(), 10u, TEST_LOCATION );
 420   DALI_TEST_EQUALS( image.GetHeight(), 20u, TEST_LOCATION );
 421   END_TEST;
 422 }
 423
 424 int UtcDaliScriptingNewImage05P(void)
 425 {
 426   TestApplication application;
 427
 428   Property::Map map;
 429   map[ "filename" ] = "TEST_FILE";
 430
 431   // width and height
 432   map[ "width"] = 50;
 433   map[ "height" ] = 70;
 434   Image image = NewImage( map );
 435   DALI_TEST_EQUALS( image.GetWidth(), 50u, TEST_LOCATION );
 436   DALI_TEST_EQUALS( image.GetHeight(), 70u, TEST_LOCATION );
 437   END_TEST;
 438 }
 439
 440 int UtcDaliScriptingNewImage06P(void)
 441 {
 442   TestApplication application;
 443
 444   Property::Map map;
 445   // type FrameBufferImage
 446   map[ "type" ] = "FrameBufferImage";
 447   // width and height
 448   map[ "width"] = 50;
 449   map[ "height" ] = 70;
 450   Image image = NewImage( map );
 451   DALI_TEST_CHECK( image );
 452   DALI_TEST_CHECK( FrameBufferImage::DownCast( image ) );
 453   END_TEST;
 454 }
 455
 456 int UtcDaliScriptingNewImage07P(void)
 457 {
 458   TestApplication application;
 459
 460   Property::Map map;
 461   // type BufferImage
 462   map[ "type" ] = "BufferImage";
 463   // width and height
 464   map[ "width"] = 50;
 465   map[ "height" ] = 70;
 466   Image image = NewImage( map );
 467   DALI_TEST_CHECK( image );
 468   DALI_TEST_CHECK( BufferImage::DownCast( image ) );
 469   DALI_TEST_EQUALS( (BufferImage::DownCast( image )).GetPixelFormat(), Pixel::RGBA8888, TEST_LOCATION );
 470   END_TEST;
 471 }
 472
 473 int UtcDaliScriptingNewImage08P(void)
 474 {
 475   TestApplication application;
 476
 477   Property::Map map;
 478   map[ "type" ] = "BufferImage";
 479   // width and height
 480   map[ "width"] = 66;
 481   map[ "height" ] = 99;
 482   // pixel-format
 483   map[ "pixelFormat" ] = "";
 484   const StringEnum values[] =
 485   {
 486     { "A8", Pixel::A8 },
 487     { "L8", Pixel::L8 },
 488     { "LA88", Pixel::LA88 },
 489     { "RGB565", Pixel::RGB565 },
 490     { "BGR565", Pixel::BGR565 },
 491     { "RGBA4444", Pixel::RGBA4444 },
 492     { "BGRA4444", Pixel::BGRA4444 },
 493     { "RGBA5551", Pixel::RGBA5551 },
 494     { "BGRA5551", Pixel::BGRA5551 },
 495     { "RGB888", Pixel::RGB888 },
 496     { "RGB8888", Pixel::RGB8888 },
 497     { "BGR8888", Pixel::BGR8888 },
 498     { "RGBA8888", Pixel::RGBA8888 },
 499     { "BGRA8888", Pixel::BGRA8888 },
 500     // BufferImage does not support compressed formats
 501   };
 502   TestEnumStrings< Pixel::Format, BufferImage >( map, "pixelFormat",  values, ( sizeof( values ) / sizeof ( values[0] ) ), &BufferImage::GetPixelFormat, &NewBufferImage );
 503
 504   END_TEST;
 505 }
 506
 507 int UtcDaliScriptingNewImage09P(void)
 508 {
 509   TestApplication application;
 510
 511   Property::Map map;
 512   // type Image
 513   map[ "type" ] = "ResourceImage";
 514   map[ "filename" ] = "TEST_FILE";
 515
 516   {
 517     Image image = NewImage( map );
 518     DALI_TEST_CHECK( ResourceImage::DownCast( image ) );
 519     DALI_TEST_CHECK( !FrameBufferImage::DownCast( image ) );
 520     DALI_TEST_CHECK( !BufferImage::DownCast( image ) );
 521   }
 522   END_TEST;
 523 }
 524
 525 int UtcDaliScriptingNewImage10P(void)
 526 {
 527   TestApplication application;
 528
 529   Property::Map map;
 530   // type FrameBufferImage, empty size gives us stage size
 531   map[ "type" ] = "FrameBufferImage";
 532   Image image = NewImage( map );
 533   DALI_TEST_CHECK( image );
 534   END_TEST;
 535 }
 536
 537 int UtcDaliScriptingNewActorNegative(void)
 538 {
 539   TestApplication application;
 540
 541   // Empty map
 542   {
 543     Actor handle = NewActor( Property::Map() );
 544     DALI_TEST_CHECK( !handle );
 545   }
 546
 547   // Map with only properties
 548   {
 549     Property::Map map;
 550     map[ "parentOrigin" ] = ParentOrigin::TOP_CENTER;
 551     map[ "anchorPoint" ] = AnchorPoint::TOP_CENTER;
 552     Actor handle = NewActor( map );
 553     DALI_TEST_CHECK( !handle );
 554   }
 555
 556   // Add some signals to the map, we should have no signal connections as its not yet supported
 557   {
 558     Property::Map map;
 559     map[ "type" ] = "Actor";
 560     map[ "signals" ] = Property::MAP;
 561     Actor handle = NewActor( map );
 562     DALI_TEST_CHECK( handle );
 563     DALI_TEST_CHECK( !handle.WheelEventSignal().GetConnectionCount() );
 564     DALI_TEST_CHECK( !handle.OffStageSignal().GetConnectionCount() );
 565     DALI_TEST_CHECK( !handle.OnStageSignal().GetConnectionCount() );
 566     DALI_TEST_CHECK( !handle.TouchedSignal().GetConnectionCount() );
 567   }
 568   END_TEST;
 569 }
 570
 571 int UtcDaliScriptingNewActorProperties(void)
 572 {
 573   TestApplication application;
 574
 575   Property::Map map;
 576   map[ "type" ] = "Actor";
 577   map[ "size" ] = Vector3::ONE;
 578   map[ "position" ] = Vector3::XAXIS;
 579   map[ "scale" ] = Vector3::ONE;
 580   map[ "visible" ] = false;
 581   map[ "color" ] = Color::MAGENTA;
 582   map[ "name" ] = "MyActor";
 583   map[ "colorMode" ] = "USE_PARENT_COLOR";
 584   map[ "sensitive" ] = false;
 585   map[ "leaveRequired" ] = true;
 586   map[ "positionInheritance" ] = "DONT_INHERIT_POSITION";
 587   map[ "drawMode" ] = "STENCIL";
 588   map[ "inheritOrientation" ] = false;
 589   map[ "inheritScale" ] = false;
 590
 591   // Default properties
 592   {
 593     Actor handle = NewActor( map );
 594     DALI_TEST_CHECK( handle );
 595
 596     Stage::GetCurrent().Add( handle );
 597     application.SendNotification();
 598     application.Render();
 599
 600     DALI_TEST_EQUALS( handle.GetCurrentSize(), Vector3::ONE, TEST_LOCATION );
 601     DALI_TEST_EQUALS( handle.GetCurrentPosition(), Vector3::XAXIS, TEST_LOCATION );
 602     DALI_TEST_EQUALS( handle.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
 603     DALI_TEST_EQUALS( handle.IsVisible(), false, TEST_LOCATION );
 604     DALI_TEST_EQUALS( handle.GetCurrentColor(), Color::MAGENTA, TEST_LOCATION );
 605     DALI_TEST_EQUALS( handle.GetName(), "MyActor", TEST_LOCATION );
 606     DALI_TEST_EQUALS( handle.GetColorMode(), USE_PARENT_COLOR, TEST_LOCATION );
 607     DALI_TEST_EQUALS( handle.IsSensitive(), false, TEST_LOCATION );
 608     DALI_TEST_EQUALS( handle.GetLeaveRequired(), true, TEST_LOCATION );
 609     DALI_TEST_EQUALS( handle.GetPositionInheritanceMode(), DONT_INHERIT_POSITION, TEST_LOCATION );
 610     DALI_TEST_EQUALS( handle.GetDrawMode(), DrawMode::STENCIL, TEST_LOCATION );
 611     DALI_TEST_EQUALS( handle.IsOrientationInherited(), false, TEST_LOCATION );
 612     DALI_TEST_EQUALS( handle.IsScaleInherited(), false, TEST_LOCATION );
 613
 614     Stage::GetCurrent().Remove( handle );
 615   }
 616
 617   // Check Anchor point and parent origin vector3s
 618   map[ "parentOrigin" ] = ParentOrigin::TOP_CENTER;
 619   map[ "anchorPoint" ] = AnchorPoint::TOP_LEFT;
 620   {
 621     Actor handle = NewActor( map );
 622     DALI_TEST_CHECK( handle );
 623
 624     Stage::GetCurrent().Add( handle );
 625     application.SendNotification();
 626     application.Render();
 627
 628     DALI_TEST_EQUALS( handle.GetCurrentParentOrigin(), ParentOrigin::TOP_CENTER, TEST_LOCATION );
 629     DALI_TEST_EQUALS( handle.GetCurrentAnchorPoint(), AnchorPoint::TOP_LEFT, TEST_LOCATION );
 630
 631     Stage::GetCurrent().Remove( handle );
 632   }
 633
 634   // Check Anchor point and parent origin STRINGS
 635   map[ "parentOrigin" ] = "TOP_LEFT";
 636   map[ "anchorPoint" ] = "CENTER_LEFT";
 637   {
 638     Actor handle = NewActor( map );
 639     DALI_TEST_CHECK( handle );
 640
 641     Stage::GetCurrent().Add( handle );
 642     application.SendNotification();
 643     application.Render();
 644
 645     DALI_TEST_EQUALS( handle.GetCurrentParentOrigin(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
 646     DALI_TEST_EQUALS( handle.GetCurrentAnchorPoint(), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
 647
 648     Stage::GetCurrent().Remove( handle );
 649   }
 650   END_TEST;
 651 }
 652
 653 int UtcDaliScriptingNewActorChildren(void)
 654 {
 655   TestApplication application;
 656
 657   Property::Map map;
 658   map[ "type" ] = "Actor";
 659   map[ "position" ] = Vector3::XAXIS;
 660
 661   Property::Map child1Map;
 662   child1Map[ "type" ] = "CameraActor";
 663   child1Map[ "position" ] = Vector3::YAXIS;
 664
 665   Property::Array childArray;
 666   childArray.PushBack( child1Map );
 667   map[ "actors" ] = childArray;
 668
 669   // Create
 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.GetCurrentPosition(), Vector3::XAXIS, TEST_LOCATION );
 678   DALI_TEST_EQUALS( handle.GetChildCount(), 1u, TEST_LOCATION );
 679
 680   Actor child1 = handle.GetChildAt(0);
 681   DALI_TEST_CHECK( child1 );
 682   DALI_TEST_CHECK( CameraActor::DownCast( child1 ) );
 683   DALI_TEST_EQUALS( child1.GetCurrentPosition(), Vector3::YAXIS, TEST_LOCATION );
 684   DALI_TEST_EQUALS( child1.GetChildCount(), 0u, TEST_LOCATION );
 685
 686   Stage::GetCurrent().Remove( handle );
 687   END_TEST;
 688 }
 689
 690
 691 int UtcDaliScriptingCreatePropertyMapActor(void)
 692 {
 693   TestApplication application;
 694
 695   // Actor Type
 696   {
 697     Actor actor = Actor::New();
 698
 699     Property::Map map;
 700     CreatePropertyMap( actor, map );
 701     DALI_TEST_CHECK( !map.Empty() );
 702     DALI_TEST_CHECK( NULL != map.Find( "type" ) );
 703     DALI_TEST_EQUALS( map.Find( "type")->Get< std::string >(), "Actor", TEST_LOCATION );
 704
 705     Stage::GetCurrent().Remove( actor );
 706   }
 707
 708   // Layer Type
 709   {
 710     Actor actor = Layer::New();
 711
 712     Property::Map map;
 713     CreatePropertyMap( actor, map );
 714     DALI_TEST_CHECK( !map.Empty() );
 715     DALI_TEST_CHECK( NULL != map.Find( "type" ) );
 716     DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "Layer", TEST_LOCATION );
 717
 718     Stage::GetCurrent().Remove( actor );
 719   }
 720
 721   // Default properties
 722   {
 723     Actor actor = Actor::New();
 724     actor.SetSize( Vector3::ONE );
 725     actor.SetPosition( Vector3::XAXIS );
 726     actor.SetScale( Vector3::ZAXIS );
 727     actor.SetVisible( false );
 728     actor.SetColor( Color::MAGENTA );
 729     actor.SetName( "MyActor" );
 730     actor.SetAnchorPoint( AnchorPoint::CENTER_LEFT );
 731     actor.SetParentOrigin( ParentOrigin::TOP_RIGHT );
 732     actor.SetSensitive( false );
 733     actor.SetLeaveRequired( true );
 734     actor.SetInheritOrientation( false );
 735     actor.SetInheritScale( false );
 736     actor.SetSizeModeFactor( Vector3::ONE );
 737
 738     Stage::GetCurrent().Add( actor );
 739     application.SendNotification();
 740     application.Render();
 741
 742     Property::Map map;
 743     CreatePropertyMap( actor, map );
 744
 745     DALI_TEST_CHECK( !map.Empty() );
 746     DALI_TEST_CHECK( NULL != map.Find( "size" ) );
 747     DALI_TEST_EQUALS( map.Find( "size" )->Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
 748     DALI_TEST_CHECK( NULL != map.Find( "position" ) );
 749     DALI_TEST_EQUALS( map.Find( "position" )->Get< Vector3 >(), Vector3::XAXIS, TEST_LOCATION );
 750     DALI_TEST_CHECK( NULL != map.Find( "scale" ) );
 751     DALI_TEST_EQUALS( map.Find( "scale" )->Get< Vector3 >(), Vector3::ZAXIS, TEST_LOCATION );
 752     DALI_TEST_CHECK( NULL != map.Find( "visible" ) );
 753     DALI_TEST_EQUALS( map.Find( "visible" )->Get< bool >(), false, TEST_LOCATION );
 754     DALI_TEST_CHECK( NULL != map.Find( "color" ) );
 755     DALI_TEST_EQUALS( map.Find( "color" )->Get< Vector4 >(), Color::MAGENTA, TEST_LOCATION );
 756     DALI_TEST_CHECK( NULL != map.Find( "name" ) );
 757     DALI_TEST_EQUALS( map.Find( "name")->Get< std::string >(), "MyActor", TEST_LOCATION );
 758     DALI_TEST_CHECK( NULL != map.Find( "anchorPoint" ) );
 759     DALI_TEST_EQUALS( map.Find( "anchorPoint" )->Get< Vector3 >(), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
 760     DALI_TEST_CHECK( NULL != map.Find( "parentOrigin" ) );
 761     DALI_TEST_EQUALS( map.Find( "parentOrigin" )->Get< Vector3 >(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
 762     DALI_TEST_CHECK( NULL != map.Find( "sensitive" ) );
 763     DALI_TEST_EQUALS( map.Find( "sensitive" )->Get< bool >(), false, TEST_LOCATION );
 764     DALI_TEST_CHECK( NULL != map.Find( "leaveRequired" ) );
 765     DALI_TEST_EQUALS( map.Find( "leaveRequired" )->Get< bool >(), true, TEST_LOCATION );
 766     DALI_TEST_CHECK( NULL != map.Find( "inheritOrientation" ) );
 767     DALI_TEST_EQUALS( map.Find( "inheritOrientation" )->Get< bool >(), false, TEST_LOCATION );
 768     DALI_TEST_CHECK( NULL != map.Find( "inheritScale" ) );
 769     DALI_TEST_EQUALS( map.Find( "inheritScale" )->Get< bool >(), false, TEST_LOCATION );
 770     DALI_TEST_CHECK( NULL != map.Find( "sizeModeFactor" ) );
 771     DALI_TEST_EQUALS( map.Find( "sizeModeFactor" )->Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
 772
 773     Stage::GetCurrent().Remove( actor );
 774   }
 775
 776   // ColorMode
 777   TestEnumStrings< ColorMode >( "colorMode",  application, COLOR_MODE_VALUES, COLOR_MODE_VALUES_COUNT, &Actor::SetColorMode );
 778
 779   // PositionInheritanceMode
 780   TestEnumStrings< PositionInheritanceMode >( "positionInheritance",  application, POSITION_INHERITANCE_MODE_VALUES, POSITION_INHERITANCE_MODE_VALUES_COUNT, &Actor::SetPositionInheritanceMode );
 781
 782   // DrawMode
 783   TestEnumStrings< DrawMode::Type >( "drawMode",  application, DRAW_MODE_VALUES, DRAW_MODE_VALUES_COUNT, &Actor::SetDrawMode );
 784
 785   // Children
 786   {
 787     Actor actor = Actor::New();
 788     Actor child = Layer::New();
 789     actor.Add( child );
 790
 791     Stage::GetCurrent().Add( actor );
 792     application.SendNotification();
 793     application.Render();
 794
 795     Property::Map map;
 796     CreatePropertyMap( actor, map );
 797     DALI_TEST_CHECK( !map.Empty() );
 798
 799     DALI_TEST_CHECK( NULL != map.Find( "type" ) );
 800     DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "Actor", TEST_LOCATION );
 801
 802     DALI_TEST_CHECK( NULL != map.Find( "actors" ) );
 803     Property::Array children( map.Find( "actors")->Get< Property::Array >() );
 804     DALI_TEST_CHECK( !children.Empty() );
 805     Property::Map childMap( children[0].Get< Property::Map >() );
 806     DALI_TEST_CHECK( !childMap.Empty() );
 807     DALI_TEST_CHECK( childMap.Find( "type" ) );
 808     DALI_TEST_EQUALS( childMap.Find( "type" )->Get< std::string >(), "Layer", TEST_LOCATION );
 809
 810     Stage::GetCurrent().Remove( actor );
 811   }
 812   END_TEST;
 813 }
 814
 815 int UtcDaliScriptingCreatePropertyMapImage(void)
 816 {
 817   TestApplication application;
 818
 819   // Empty
 820   {
 821     Image image;
 822     Property::Map map;
 823     CreatePropertyMap( image, map );
 824     DALI_TEST_CHECK( map.Empty() );
 825   }
 826
 827   // Default
 828   {
 829     Image image = ResourceImage::New( "MY_PATH" );
 830
 831     Property::Map map;
 832     CreatePropertyMap( image, map );
 833     DALI_TEST_CHECK( !map.Empty() );
 834
 835     DALI_TEST_CHECK( NULL != map.Find( "type" ) );
 836     DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "ResourceImage", TEST_LOCATION );
 837     DALI_TEST_CHECK( NULL != map.Find( "filename" ) );
 838     DALI_TEST_EQUALS( map.Find( "filename" )->Get< std::string >(), "MY_PATH", TEST_LOCATION );
 839     DALI_TEST_CHECK( NULL != map.Find( "loadPolicy") );
 840     DALI_TEST_EQUALS( map.Find( "loadPolicy" )->Get< std::string >(), "IMMEDIATE", TEST_LOCATION );
 841     DALI_TEST_CHECK( NULL != map.Find( "releasePolicy") );
 842     DALI_TEST_EQUALS( map.Find( "releasePolicy" )->Get< std::string >(), "NEVER", TEST_LOCATION );
 843     DALI_TEST_CHECK( NULL == map.Find( "width" ) );
 844     DALI_TEST_CHECK( NULL == map.Find( "height" ) );
 845   }
 846
 847   // Change values
 848   {
 849     ResourceImage image = ResourceImage::New( "MY_PATH", ResourceImage::ON_DEMAND, Image::UNUSED, ImageDimensions( 300, 400 ), FittingMode::FIT_WIDTH );
 850
 851     Property::Map map;
 852     CreatePropertyMap( image, map );
 853     DALI_TEST_CHECK( !map.Empty() );
 854
 855     DALI_TEST_CHECK( NULL != map.Find( "type" ) );
 856     DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "ResourceImage", TEST_LOCATION );
 857     DALI_TEST_CHECK( NULL != map.Find( "filename" ) );
 858     DALI_TEST_EQUALS( map.Find( "filename" )->Get< std::string >(), "MY_PATH", TEST_LOCATION );
 859     DALI_TEST_CHECK( NULL != map.Find( "loadPolicy") );
 860     DALI_TEST_EQUALS( map.Find( "loadPolicy" )->Get< std::string >(), "ON_DEMAND", TEST_LOCATION );
 861     DALI_TEST_CHECK( NULL != map.Find( "releasePolicy") );
 862     DALI_TEST_EQUALS( map.Find( "releasePolicy" )->Get< std::string >(), "UNUSED", TEST_LOCATION );
 863     DALI_TEST_CHECK( NULL != map.Find( "width" ) );
 864     DALI_TEST_EQUALS( map.Find( "width" )->Get< int >(), 300, TEST_LOCATION );
 865     DALI_TEST_CHECK( NULL != map.Find( "height" ) );
 866     DALI_TEST_EQUALS( map.Find( "height" )->Get< int >(), 400, TEST_LOCATION );
 867   }
 868
 869   // BufferImage
 870   {
 871     Image image = BufferImage::New( 200, 300, Pixel::A8 );
 872     Property::Map map;
 873     CreatePropertyMap( image, map );
 874     DALI_TEST_CHECK( NULL != map.Find( "type" ) );
 875     DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "BufferImage", TEST_LOCATION );
 876     DALI_TEST_CHECK( NULL != map.Find( "pixelFormat") );
 877     DALI_TEST_EQUALS( map.Find( "pixelFormat" )->Get< std::string >(), "A8", TEST_LOCATION );
 878   }
 879
 880   // FrameBufferImage
 881   {
 882     Image image = FrameBufferImage::New( 200, 300, Pixel::RGBA8888 );
 883     Property::Map map;
 884     CreatePropertyMap( image, map );
 885     DALI_TEST_CHECK( NULL != map.Find( "type" ) );
 886     DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "FrameBufferImage", TEST_LOCATION );
 887   }
 888   END_TEST;
 889 }
 890
 891 int UtcDaliScriptingGetEnumerationTemplates(void)
 892 {
 893   const Scripting::StringEnum myTable[] =
 894   {
 895     { "ONE",    1 },
 896     { "TWO",    2 },
 897     { "THREE",  3 },
 898     { "FOUR",   4 },
 899     { "FIVE",   5 },
 900   };
 901   const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
 902
 903   for ( unsigned int i = 0; i < myTableCount; ++i )
 904   {
 905     tet_printf("Checking: %s\n", myTable[ i ].string );
 906     int value;
 907     DALI_TEST_CHECK( GetEnumeration<int>( myTable[ i ].string, myTable, myTableCount, value ) );
 908     DALI_TEST_EQUALS( myTable[ i ].value, value, TEST_LOCATION );
 909   }
 910
 911   for ( unsigned int i = 0; i < myTableCount; ++i )
 912   {
 913     tet_printf("Checking: %d\n", myTable[ i ].value );
 914     DALI_TEST_EQUALS( myTable[ i ].string, GetEnumerationName( myTable[ i ].value, myTable, myTableCount ), TEST_LOCATION );
 915   }
 916
 917   END_TEST;
 918 }
 919
 920 int UtcDaliScriptingGetEnumerationNameN(void)
 921 {
 922   const char* value = GetEnumerationName( 10, NULL, 0 );
 923   DALI_TEST_CHECK( NULL == value );
 924
 925   value = GetEnumerationName( 10, NULL, 1 );
 926   DALI_TEST_CHECK( NULL == value );
 927
 928   END_TEST;
 929 }
 930
 931 int UtcDaliScriptingGetLinearEnumerationNameN(void)
 932 {
 933   const char* value = GetLinearEnumerationName( 10, NULL, 0 );
 934   DALI_TEST_CHECK( NULL == value );
 935
 936   value = GetLinearEnumerationName( 10, NULL, 1 );
 937   DALI_TEST_CHECK( NULL == value );
 938
 939   END_TEST;
 940 }
 941
 942 int UtcDaliScriptingFindEnumIndexN(void)
 943 {
 944   const Scripting::StringEnum myTable[] =
 945     {
 946       { "ONE",    (1<<1) },
 947       { "TWO",    (1<<2) },
 948       { "THREE",  (1<<3) },
 949       { "FOUR",   (1<<4) },
 950       { "FIVE",   (1<<5) },
 951     };
 952   const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
 953   DALI_TEST_EQUALS( myTableCount, FindEnumIndex( "Foo", myTable, myTableCount ), TEST_LOCATION );
 954
 955   END_TEST;
 956 }
 957
 958 int UtcDaliScriptingEnumStringToIntegerP(void)
 959 {
 960   const Scripting::StringEnum myTable[] =
 961     {
 962       { "ONE",    (1<<1) },
 963       { "TWO",    (1<<2) },
 964       { "THREE",  (1<<3) },
 965       { "FOUR",   (1<<4) },
 966       { "FIVE",   (1<<5) },
 967     };
 968   const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
 969
 970   unsigned int integerEnum = 0;
 971   DALI_TEST_CHECK( EnumStringToInteger( "ONE", myTable, myTableCount, integerEnum ) );
 972
 973   DALI_TEST_EQUALS( integerEnum, (1<<1), TEST_LOCATION );
 974
 975   integerEnum = 0;
 976   DALI_TEST_CHECK( EnumStringToInteger( "ONE,TWO", myTable, myTableCount, integerEnum ) );
 977   DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2), TEST_LOCATION );
 978
 979   DALI_TEST_CHECK( EnumStringToInteger( "ONE,,TWO", myTable, myTableCount, integerEnum ) );
 980   DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2), TEST_LOCATION );
 981
 982   DALI_TEST_CHECK( EnumStringToInteger( "ONE,TWO,THREE", myTable, myTableCount, integerEnum ) );
 983   DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2) | (1<<3), TEST_LOCATION );
 984
 985   DALI_TEST_CHECK( EnumStringToInteger( "ONE,TWO,THREE,FOUR,FIVE", myTable, myTableCount, integerEnum ) );
 986   DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5), TEST_LOCATION );
 987
 988   DALI_TEST_CHECK( EnumStringToInteger( "TWO,ONE", myTable, myTableCount, integerEnum ) );
 989   DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2), TEST_LOCATION );
 990
 991   DALI_TEST_CHECK( EnumStringToInteger( "TWO,ONE,FOUR,THREE,FIVE", myTable, myTableCount, integerEnum ) );
 992   DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5), TEST_LOCATION );
 993
 994   DALI_TEST_CHECK( EnumStringToInteger( "ONE,SEVEN", myTable, myTableCount, integerEnum ) );
 995   DALI_TEST_EQUALS( integerEnum, (1<<1), TEST_LOCATION );
 996
 997   DALI_TEST_CHECK( EnumStringToInteger( "ONE,", myTable, myTableCount, integerEnum ) );
 998   DALI_TEST_EQUALS( integerEnum, (1<<1), TEST_LOCATION );
 999
1000
1001   END_TEST;
1002 }
1003
1004 int UtcDaliScriptingEnumStringToIntegerN(void)
1005 {
1006   const Scripting::StringEnum myTable[] =
1007   {
1008     { "ONE",    1 },
1009     { "TWO",    2 },
1010     { "THREE",  3 },
1011     { "FOUR",   4 },
1012     { "FIVE",   5 },
1013   };
1014   const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
1015
1016   unsigned int integerEnum = 0;
1017   DALI_TEST_CHECK( !EnumStringToInteger( "Foo", myTable, myTableCount, integerEnum ) );
1018
1019   DALI_TEST_CHECK( !EnumStringToInteger( "", myTable, myTableCount, integerEnum ) );
1020
1021   DALI_TEST_CHECK( !EnumStringToInteger( ",", myTable, myTableCount, integerEnum ) );
1022
1023   DALI_TEST_CHECK( !EnumStringToInteger( ",ONE,SEVEN", myTable, myTableCount, integerEnum ) );
1024
1025   DALI_TEST_CHECK( !EnumStringToInteger( ",", myTable, myTableCount, integerEnum ) );
1026
1027   DALI_TEST_CHECK( !EnumStringToInteger( "ONE", myTable, 0, integerEnum ) );
1028
1029   DALI_TEST_EQUALS( integerEnum, 0, TEST_LOCATION );
1030
1031   END_TEST;
1032 }
1033
1034 int UtcDaliScriptingEnumStringToIntegerInvalidEnumP(void)
1035 {
1036   const Scripting::StringEnum myTable[] =
1037   {
1038     { "",    1 },
1039     { "",    2 },
1040     { "",    3 },
1041   };
1042
1043   const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
1044
1045   unsigned int integerEnum = 0;
1046   DALI_TEST_CHECK( EnumStringToInteger( "", myTable, myTableCount, integerEnum ) );
1047   DALI_TEST_EQUALS( integerEnum, 1, TEST_LOCATION );
1048
1049   END_TEST;
1050 }
1051
1052 int UtcDaliScriptingEnumStringToIntegerInvalidEnumN(void)
1053 {
1054   const Scripting::StringEnum myTable[] =
1055   {
1056     { "",    1 },
1057     { "",    1 },
1058     { "",    1 },
1059   };
1060
1061   const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
1062
1063   unsigned int integerEnum = 0;
1064   DALI_TEST_CHECK( !EnumStringToInteger( NULL, NULL, 0, integerEnum ) );
1065
1066   DALI_TEST_CHECK( !EnumStringToInteger( "ONE", NULL, 0, integerEnum ) );
1067
1068   DALI_TEST_CHECK( !EnumStringToInteger( NULL, myTable, 0, integerEnum ) );
1069
1070   DALI_TEST_CHECK( !EnumStringToInteger( NULL, myTable, myTableCount, integerEnum ) );
1071
1072   DALI_TEST_CHECK( !EnumStringToInteger( "ONE", NULL, myTableCount, integerEnum ) );
1073
1074   DALI_TEST_EQUALS( integerEnum, 0, TEST_LOCATION );
1075
1076   END_TEST;
1077 }