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

   1 /*
   2  * Copyright (c) 2017 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 #include <stdlib.h>
  20 #include <limits>
  21 #include <dali/public-api/dali-core.h>
  22 #include <dali-test-suite-utils.h>
  23 #include <dali/internal/event/common/type-info-impl.h>
  24 #include <dali/integration-api/events/long-press-gesture-event.h>
  25 #include <dali/integration-api/events/pan-gesture-event.h>
  26 #include <dali/integration-api/events/pinch-gesture-event.h>
  27 #include <dali/integration-api/events/tap-gesture-event.h>
  28 #include <dali/integration-api/events/touch-event-integ.h>
  29 #include <dali/integration-api/events/hover-event-integ.h>
  30
  31 using namespace Dali;
  32
  33
  34 namespace
  35 {
  36
  37 // Stores data that is populated in the callback and will be read by the Test cases
  38 struct SignalData
  39 {
  40   SignalData()
  41   : functorCalled( false ),
  42     voidFunctorCalled( false ),
  43     receivedGesture( Gesture::Clear ),
  44     pressedActor()
  45   {}
  46
  47   void Reset()
  48   {
  49     functorCalled = false;
  50     voidFunctorCalled = false;
  51
  52     receivedGesture.numberOfTouches = 0u;
  53     receivedGesture.screenPoint = Vector2(0.0f, 0.0f);
  54     receivedGesture.localPoint = Vector2(0.0f, 0.0f);
  55
  56     pressedActor.Reset();
  57   }
  58
  59   bool functorCalled;
  60   bool voidFunctorCalled;
  61   LongPressGesture receivedGesture;
  62   Actor pressedActor;
  63 };
  64
  65 // Functor that sets the data when called
  66 struct GestureReceivedFunctor
  67 {
  68   GestureReceivedFunctor(SignalData& data) : signalData(data) { }
  69
  70   void operator()(Actor actor, LongPressGesture longPress)
  71   {
  72     signalData.functorCalled = true;
  73     signalData.receivedGesture = longPress;
  74     signalData.pressedActor = actor;
  75   }
  76
  77   void operator()()
  78   {
  79     signalData.voidFunctorCalled = true;
  80   }
  81
  82   SignalData& signalData;
  83 };
  84
  85 // Generate a LongPressGestureEvent to send to Core
  86 Integration::LongPressGestureEvent GenerateLongPress(
  87     Gesture::State state,
  88     unsigned int numberOfTouches,
  89     Vector2 point)
  90 {
  91   Integration::LongPressGestureEvent longPress( state );
  92
  93   longPress.numberOfTouches = numberOfTouches;
  94   longPress.point = point;
  95
  96   return longPress;
  97 }
  98
  99 // Generate a PanGestureEvent to send to Core
 100 Integration::PanGestureEvent GeneratePan(
 101     Gesture::State state,
 102     Vector2 previousPosition,
 103     Vector2 currentPosition,
 104     unsigned long timeDelta,
 105     unsigned int numberOfTouches = 1,
 106     unsigned int time = 1u)
 107 {
 108   Integration::PanGestureEvent pan(state);
 109
 110   pan.previousPosition = previousPosition;
 111   pan.currentPosition = currentPosition;
 112   pan.timeDelta = timeDelta;
 113   pan.numberOfTouches = numberOfTouches;
 114   pan.time = time;
 115
 116   return pan;
 117 }
 118 // Generate a PinchGestureEvent to send to Core
 119 Integration::PinchGestureEvent GeneratePinch(
 120     Gesture::State state,
 121     float scale,
 122     float speed,
 123     Vector2 centerpoint)
 124 {
 125   Integration::PinchGestureEvent pinch(state);
 126
 127   pinch.scale = scale;
 128   pinch.speed = speed;
 129   pinch.centerPoint = centerpoint;
 130
 131   return pinch;
 132 }
 133 // Generate a TapGestureEvent to send to Core
 134 Integration::TapGestureEvent GenerateTap(
 135     Gesture::State state,
 136     unsigned int numberOfTaps,
 137     unsigned int numberOfTouches,
 138     Vector2 point)
 139 {
 140   Integration::TapGestureEvent tap( state );
 141
 142   tap.numberOfTaps = numberOfTaps;
 143   tap.numberOfTouches = numberOfTouches;
 144   tap.point = point;
 145
 146   return tap;
 147 }
 148
 149 //
 150 // Create function as Init function called
 151 //
 152 static bool CreateCustomInitCalled = false;
 153 BaseHandle CreateCustomInit(void)
 154 {
 155   CreateCustomInitCalled = true;
 156   return BaseHandle();
 157 }
 158
 159 static bool CreateCustomNamedInitCalled = false;
 160 BaseHandle CreateCustomNamedInit(void)
 161 {
 162   CreateCustomNamedInitCalled = true;
 163   return BaseHandle();
 164 }
 165
 166 const std::string scriptedName("PopupStyle");
 167 static TypeRegistration scriptedType( scriptedName, typeid(Dali::CustomActor), CreateCustomNamedInit );
 168
 169 // Property Registration
 170 bool setPropertyCalled = false;
 171 bool getPropertyCalled = false;
 172 void SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
 173 {
 174   setPropertyCalled = true;
 175 }
 176 Property::Value GetProperty( BaseObject* object, Property::Index propertyIndex )
 177 {
 178   getPropertyCalled = true;
 179   return Property::Value( true );
 180 }
 181
 182
 183
 184 /*******************************************************************************
 185  *
 186  * Custom Actor
 187  *
 188  ******************************************************************************/
 189 namespace Impl
 190 {
 191 struct MyTestCustomActor : public CustomActorImpl
 192 {
 193   typedef Signal< void ()> SignalType;
 194   typedef Signal< void (float)> SignalTypeFloat;
 195
 196   MyTestCustomActor() : CustomActorImpl( ActorFlags( REQUIRES_TOUCH_EVENTS ) )
 197   { }
 198
 199   virtual ~MyTestCustomActor()
 200   { }
 201
 202   void ResetCallStack()
 203   {
 204   }
 205
 206   // From CustomActorImpl
 207   virtual void OnStageConnection( int depth )
 208   {
 209   }
 210   virtual void OnStageDisconnection()
 211   {
 212   }
 213   virtual void OnChildAdd(Actor& child)
 214   {
 215   }
 216   virtual void OnChildRemove(Actor& child)
 217   {
 218   }
 219   virtual void OnSizeSet(const Vector3& targetSize)
 220   {
 221   }
 222   virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize)
 223   {
 224   }
 225   virtual bool OnTouchEvent(const TouchEvent& event)
 226   {
 227     return true;
 228   }
 229   virtual bool OnHoverEvent(const HoverEvent& event)
 230   {
 231     return true;
 232   }
 233   virtual bool OnWheelEvent(const WheelEvent& event)
 234   {
 235     return true;
 236   }
 237   virtual bool OnKeyEvent(const KeyEvent& event)
 238   {
 239     return true;
 240   }
 241   virtual void OnKeyInputFocusGained()
 242   {
 243   }
 244   virtual void OnKeyInputFocusLost()
 245   {
 246   }
 247   virtual Vector3 GetNaturalSize()
 248   {
 249     return Vector3( 0.0f, 0.0f, 0.0f );
 250   }
 251
 252   virtual float GetHeightForWidth( float width )
 253   {
 254     return 0.0f;
 255   }
 256
 257   virtual float GetWidthForHeight( float height )
 258   {
 259     return 0.0f;
 260   }
 261
 262   virtual void OnRelayout( const Vector2& size, RelayoutContainer& container )
 263   {
 264   }
 265
 266   virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
 267   {
 268   }
 269
 270   virtual void OnCalculateRelayoutSize( Dimension::Type dimension )
 271   {
 272   }
 273
 274   virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
 275   {
 276     return 0.0f;
 277   }
 278
 279   virtual void OnLayoutNegotiated( float size, Dimension::Type dimension )
 280   {
 281   }
 282
 283   virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS )
 284   {
 285     return false;
 286   }
 287
 288 public:
 289
 290   SignalType mSignal;
 291 };
 292
 293 }; // namespace Impl
 294
 295 class MyTestCustomActor : public CustomActor
 296 {
 297 public:
 298
 299   typedef Signal< void ()> SignalType;
 300   typedef Signal< void (float)> SignalTypeFloat;
 301
 302   MyTestCustomActor()
 303   {
 304   }
 305
 306   static MyTestCustomActor New()
 307   {
 308     Impl::MyTestCustomActor* p = new Impl::MyTestCustomActor;
 309     return MyTestCustomActor( *p ); // takes ownership
 310   }
 311
 312   virtual ~MyTestCustomActor()
 313   {
 314   }
 315
 316   static MyTestCustomActor DownCast( BaseHandle handle )
 317   {
 318     MyTestCustomActor result;
 319
 320     CustomActor custom = Dali::CustomActor::DownCast( handle );
 321     if ( custom )
 322     {
 323       CustomActorImpl& customImpl = custom.GetImplementation();
 324
 325       Impl::MyTestCustomActor* impl = dynamic_cast<Impl::MyTestCustomActor*>(&customImpl);
 326
 327       if (impl)
 328       {
 329         result = MyTestCustomActor(customImpl.GetOwner());
 330       }
 331     }
 332
 333     return result;
 334   }
 335
 336   SignalType& GetCustomSignal()
 337   {
 338     Dali::RefObject& obj = GetImplementation();
 339     return static_cast<Impl::MyTestCustomActor&>( obj ).mSignal;
 340   }
 341
 342 private:
 343
 344   MyTestCustomActor(Internal::CustomActor* internal)
 345   : CustomActor(internal)
 346   {
 347   }
 348
 349   MyTestCustomActor( Impl::MyTestCustomActor& impl )
 350   : CustomActor( impl )
 351   {
 352   }
 353 };
 354
 355
 356 class MyTestCustomActor2 : public CustomActor
 357 {
 358 public:
 359
 360   struct Property
 361   {
 362     enum
 363     {
 364       P1=Dali::PROPERTY_REGISTRATION_START_INDEX,
 365       P2
 366     };
 367   };
 368
 369
 370   MyTestCustomActor2()
 371   {
 372   }
 373
 374   static MyTestCustomActor2 New()
 375   {
 376     return MyTestCustomActor2(); // takes ownership
 377   }
 378
 379   virtual ~MyTestCustomActor2()
 380   {
 381   }
 382
 383   static MyTestCustomActor2 DownCast( BaseHandle handle )
 384   {
 385     MyTestCustomActor2 result;
 386
 387     CustomActor custom = Dali::CustomActor::DownCast( handle );
 388     if ( custom )
 389     {
 390       CustomActorImpl& customImpl = custom.GetImplementation();
 391
 392       Impl::MyTestCustomActor* impl = dynamic_cast<Impl::MyTestCustomActor*>(&customImpl);
 393
 394       if (impl)
 395       {
 396         result = MyTestCustomActor2(customImpl.GetOwner());
 397       }
 398     }
 399
 400     return result;
 401   }
 402
 403 private:
 404
 405   MyTestCustomActor2(Internal::CustomActor* internal)
 406   : CustomActor(internal)
 407   {
 408   }
 409
 410   MyTestCustomActor2( Impl::MyTestCustomActor& impl )
 411   : CustomActor( impl )
 412   {
 413   }
 414 };
 415
 416 static TypeRegistration customTypeInit( typeid(MyTestCustomActor2), typeid(Dali::CustomActor), CreateCustomInit, true );
 417
 418 PropertyRegistration P1( customTypeInit, "propertyOne", MyTestCustomActor2::Property::P1, Property::INTEGER, &SetProperty, &GetProperty );
 419 PropertyRegistration P2( customTypeInit, "propertyTwo", MyTestCustomActor2::Property::P2, Property::STRING, &SetProperty, &GetProperty );
 420
 421
 422 class MyTestCustomActor3 : public CustomActor
 423 {
 424 public:
 425   MyTestCustomActor3()
 426   {
 427   }
 428
 429   static MyTestCustomActor3 New()
 430   {
 431     return MyTestCustomActor3(); // takes ownership
 432   }
 433
 434   virtual ~MyTestCustomActor3()
 435   {
 436   }
 437
 438   static MyTestCustomActor3 DownCast( BaseHandle handle )
 439   {
 440     MyTestCustomActor3 result;
 441
 442     CustomActor custom = Dali::CustomActor::DownCast( handle );
 443     if ( custom )
 444     {
 445       CustomActorImpl& customImpl = custom.GetImplementation();
 446
 447       Impl::MyTestCustomActor* impl = dynamic_cast<Impl::MyTestCustomActor*>(&customImpl);
 448
 449       if (impl)
 450       {
 451         result = MyTestCustomActor3(customImpl.GetOwner());
 452       }
 453     }
 454
 455     return result;
 456   }
 457
 458 private:
 459
 460   MyTestCustomActor3(Internal::CustomActor* internal)
 461   : CustomActor(internal)
 462   {
 463   }
 464
 465   MyTestCustomActor3( Impl::MyTestCustomActor& impl )
 466   : CustomActor( impl )
 467   {
 468   }
 469 };
 470
 471 static TypeRegistration customTypeBadInit( typeid(MyTestCustomActor3), typeid(Dali::CustomActor), NULL, false );
 472
 473 BaseHandle CreateCustom(void)
 474 {
 475   return MyTestCustomActor::New();
 476 }
 477
 478 static std::string lastSignalConnectionCustom;
 479
 480 bool DoConnectSignalCustom( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 481 {
 482   lastSignalConnectionCustom = signalName;
 483
 484   bool connected( true );
 485
 486   Dali::BaseHandle handle(object);
 487   MyTestCustomActor customActor = MyTestCustomActor::DownCast(handle);
 488
 489   if( "sig1" == signalName )
 490   {
 491     customActor.GetCustomSignal().Connect( tracker, functor );
 492   }
 493   else
 494   {
 495     // signalName does not match any signal
 496     connected = false;
 497   }
 498
 499   return connected;
 500 }
 501
 502 bool DoConnectSignalCustomFailure( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
 503 {
 504   lastSignalConnectionCustom = "failed";
 505
 506   return false; // This is supposed to fail
 507 }
 508
 509 struct CustomTestFunctor
 510 {
 511   CustomTestFunctor()
 512   {
 513     ++mTotalInstanceCount;
 514     ++mCurrentInstanceCount;
 515   }
 516
 517   CustomTestFunctor( const CustomTestFunctor& copyMe )
 518   {
 519     ++mTotalInstanceCount;
 520     ++mCurrentInstanceCount;
 521   }
 522
 523   ~CustomTestFunctor()
 524   {
 525     --mCurrentInstanceCount;
 526   }
 527
 528   void operator()()
 529   {
 530     ++mCallbackCount;
 531   }
 532
 533   static int mTotalInstanceCount;
 534   static int mCurrentInstanceCount;
 535   static int mCallbackCount;
 536 };
 537
 538 int CustomTestFunctor::mTotalInstanceCount = 0;
 539 int CustomTestFunctor::mCurrentInstanceCount = 0;
 540 int CustomTestFunctor::mCallbackCount = 0;
 541
 542 static void ResetFunctorCounts()
 543 {
 544   CustomTestFunctor::mTotalInstanceCount   = 0;
 545   CustomTestFunctor::mCurrentInstanceCount = 0;
 546   CustomTestFunctor::mCallbackCount        = 0;
 547 }
 548
 549 static std::string lastActionCustom;
 550 bool DoActionCustom(BaseObject* object, const std::string& actionName, const Property::Map& /*attributes*/)
 551 {
 552   lastActionCustom = actionName;
 553   return true;
 554 }
 555
 556 // Custom type registration
 557 static TypeRegistration customType1( typeid(MyTestCustomActor), typeid(Dali::CustomActor), CreateCustom );
 558
 559 // Custom signals
 560 static SignalConnectorType customSignalConnector1( customType1, "sig1", DoConnectSignalCustom );
 561 static SignalConnectorType customSignalConnector2( customType1, "sig2", DoConnectSignalCustomFailure );
 562 static const int TEST_SIGNAL_COUNT = 2;
 563
 564 // Custom actions
 565 static TypeAction customAction1( customType1, "act1", DoActionCustom);
 566 static const int TEST_ACTION_COUNT = 1;
 567
 568 class TestConnectionTracker : public ConnectionTracker
 569 {
 570 public:
 571
 572   TestConnectionTracker()
 573   {
 574   }
 575 };
 576
 577 BaseHandle CreateNamedActorType()
 578 {
 579   Actor actor = Actor::New();
 580   actor.SetName( "NamedActor" );
 581   return actor;
 582 }
 583
 584 TypeRegistration namedActorType( "MyNamedActor", typeid(Dali::Actor), CreateNamedActorType );
 585 PropertyRegistration namedActorPropertyOne( namedActorType, "propName",  PROPERTY_REGISTRATION_START_INDEX, Property::BOOLEAN, &SetProperty, &GetProperty );
 586
 587 } // Anonymous namespace
 588
 589 // Note: No negative test case for UtcDaliTypeRegistryGet can be implemented.
 590 int UtcDaliTypeRegistryGetP(void)
 591 {
 592   TestApplication application;
 593
 594   TypeRegistry registry = TypeRegistry::Get();
 595   DALI_TEST_CHECK( registry );
 596
 597   END_TEST;
 598 }
 599
 600 // Note: No negative test case for UtcDaliTypeRegistryConstructor can be implemented.
 601 int UtcDaliTypeRegistryConstructorP(void)
 602 {
 603   TestApplication application;
 604
 605   TypeRegistry registry;
 606   DALI_TEST_CHECK( !registry );
 607   END_TEST;
 608 }
 609
 610 // Note: No negative test case for UtcDaliTypeRegistryCopyConstructor can be implemented.
 611 int UtcDaliTypeRegistryCopyConstructorP(void)
 612 {
 613   TestApplication application;
 614
 615   TypeRegistry registry = TypeRegistry::Get();
 616   DALI_TEST_CHECK( registry );
 617
 618   TypeRegistry copy( registry );
 619   DALI_TEST_CHECK( copy );
 620
 621   DALI_TEST_CHECK( registry.GetTypeInfo( "Actor" ).GetName() == copy.GetTypeInfo( "Actor" ).GetName() );
 622
 623   END_TEST;
 624 }
 625
 626 // Note: No negative test case for UtcDaliTypeRegistryAssignmentOperator can be implemented.
 627 int UtcDaliTypeRegistryAssignmentOperatorP(void)
 628 {
 629   TestApplication application;
 630
 631   TypeRegistry registry = TypeRegistry::Get();
 632   DALI_TEST_CHECK( registry );
 633
 634   TypeRegistry copy = registry;
 635   DALI_TEST_CHECK( copy );
 636   DALI_TEST_CHECK( registry == copy );
 637
 638   DALI_TEST_CHECK( registry.GetTypeInfo( "Actor" ).GetName() == copy.GetTypeInfo( "Actor" ).GetName() );
 639
 640   END_TEST;
 641 }
 642
 643 int UtcDaliTypeRegistryAssignP(void)
 644 {
 645   TestApplication application;
 646
 647   TypeRegistry registry = TypeRegistry::Get();
 648   TypeRegistry registry2;
 649   registry2 = registry;
 650   DALI_TEST_CHECK( registry2 );
 651
 652   DALI_TEST_CHECK( registry2.GetTypeInfo( "Actor" ).GetName() == registry2.GetTypeInfo( "Actor" ).GetName() );
 653
 654   END_TEST;
 655 }
 656
 657 int UtcDaliTypeRegistryGetTypeInfoFromTypeNameP(void)
 658 {
 659   TestApplication application;
 660
 661   TypeRegistry registry = TypeRegistry::Get();
 662
 663   TypeInfo type;
 664
 665   // camera actor
 666   type = registry.GetTypeInfo( "CameraActor" );
 667   DALI_TEST_CHECK( type );
 668   CameraActor ca = CameraActor::DownCast(type.CreateInstance());
 669   DALI_TEST_CHECK( ca );
 670   Stage::GetCurrent().Add( ca );
 671   application.Render();
 672
 673   // animations
 674   type = registry.GetTypeInfo( "Animation" );
 675   DALI_TEST_CHECK( type );
 676   Animation an = Animation::DownCast(type.CreateInstance());
 677   DALI_TEST_CHECK( an );
 678   an.Play();
 679   application.Render();
 680
 681   END_TEST;
 682 }
 683
 684 int UtcDaliTypeRegistryGetTypeInfoFromTypeNameN(void)
 685 {
 686   TestApplication application;
 687
 688   TypeRegistry registry = TypeRegistry::Get();
 689
 690   TypeInfo type;
 691
 692   type = registry.GetTypeInfo( "MyDummyActor" );
 693   DALI_TEST_CHECK( !type );
 694
 695   END_TEST;
 696 }
 697
 698 int UtcDaliTypeRegistryGetTypeInfoFromTypeIdP(void)
 699 {
 700   TypeInfo named_type = TypeRegistry::Get().GetTypeInfo( "CameraActor" );
 701   TypeInfo typeinfo_type = TypeRegistry::Get().GetTypeInfo( typeid(Dali::CameraActor) );
 702
 703   DALI_TEST_CHECK( named_type );
 704   DALI_TEST_CHECK( typeinfo_type );
 705
 706   // Check named and typeid are equivalent
 707   DALI_TEST_CHECK( named_type == typeinfo_type );
 708
 709   DALI_TEST_CHECK( named_type.GetName() == typeinfo_type.GetName() );
 710   DALI_TEST_CHECK( named_type.GetBaseName() == typeinfo_type.GetBaseName() );
 711
 712   END_TEST;
 713 }
 714
 715 int UtcDaliTypeRegistryGetTypeInfoFromTypeIdN(void)
 716 {
 717   TestApplication application;
 718   TypeRegistry typeRegistry = TypeRegistry::Get();
 719
 720   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(Vector2) );
 721   DALI_TEST_CHECK( !typeInfo );
 722
 723   END_TEST;
 724 }
 725
 726 int UtcDaliTypeRegistryGetTypeNameCountP(void)
 727 {
 728   TestApplication application;
 729   TypeRegistry typeRegistry = TypeRegistry::Get();
 730   TypeInfo type;
 731
 732   for(size_t i = 0; i < typeRegistry.GetTypeNameCount(); i++)
 733   {
 734     type = typeRegistry.GetTypeInfo( typeRegistry.GetTypeName(i) );
 735     DALI_TEST_CHECK( type );
 736   }
 737
 738   END_TEST;
 739 }
 740
 741
 742 int UtcDaliTypeRegistryGetTypeNamesP(void)
 743 {
 744   TestApplication application;
 745   TypeRegistry typeRegistry = TypeRegistry::Get();
 746   TypeInfo type;
 747
 748   for(size_t i = 0; i < typeRegistry.GetTypeNameCount(); i++)
 749   {
 750     type = typeRegistry.GetTypeInfo( typeRegistry.GetTypeName(i) );
 751     DALI_TEST_CHECK( type );
 752   }
 753
 754   END_TEST;
 755 }
 756
 757
 758 // Note: No negative test case for UtcDaliTypeRegistryTypeRegistration can be implemented.
 759 int UtcDaliTypeRegistryTypeRegistrationNotCallingCreateOnInitP(void)
 760 {
 761   ResetFunctorCounts();
 762
 763   TestApplication application;
 764
 765   TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor" );
 766   DALI_TEST_CHECK( type );
 767
 768   TypeInfo baseType = TypeRegistry::Get().GetTypeInfo( "CustomActor" );
 769   DALI_TEST_CHECK( baseType );
 770
 771   BaseHandle handle = type.CreateInstance();
 772   DALI_TEST_CHECK( handle );
 773
 774   MyTestCustomActor customHandle = MyTestCustomActor::DownCast( handle );
 775   DALI_TEST_CHECK( customHandle );
 776
 777   DALI_TEST_EQUALS( type.GetActionCount(), TEST_ACTION_COUNT + baseType.GetActionCount(), TEST_LOCATION );
 778
 779   DALI_TEST_EQUALS( type.GetSignalCount(), TEST_SIGNAL_COUNT + baseType.GetSignalCount(), TEST_LOCATION );
 780
 781   {
 782     TestConnectionTracker tracker;
 783
 784     bool connected = handle.ConnectSignal( &tracker, "sig1", CustomTestFunctor() );
 785     DALI_TEST_EQUALS( connected, true, TEST_LOCATION );
 786     DALI_TEST_CHECK( lastSignalConnectionCustom == "sig1" );
 787     DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
 788     DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION );
 789
 790     DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION );
 791     customHandle.GetCustomSignal().Emit();
 792     DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION );
 793     DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
 794     DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION );
 795   }
 796   // tracker should automatically disconnect here
 797   DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
 798   DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION );
 799
 800   // Test that functor is disconnected
 801   DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION );
 802   customHandle.GetCustomSignal().Emit();
 803   DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1/*not incremented*/, TEST_LOCATION );
 804   DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
 805   DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION );
 806
 807   Property::Map attributes;
 808   handle.DoAction("act1", attributes);
 809   DALI_TEST_CHECK( lastActionCustom == "act1" );
 810   END_TEST;
 811 }
 812
 813 // Note: No negative test case for UtcDaliTypeRegistryTypeRegistration can be implemented.
 814 int UtcDaliTypeRegistryTypeRegistrationCallingCreateOnInitP(void)
 815 {
 816   TestApplication application;
 817
 818   DALI_TEST_CHECK( "MyTestCustomActor2" == customTypeInit.RegisteredName() );
 819
 820   DALI_TEST_CHECK( true == CreateCustomInitCalled );
 821   TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor2" );
 822   DALI_TEST_CHECK( type );
 823   END_TEST;
 824 }
 825
 826 // Note: No negative test case for UtcDaliTypeRegistryTypeRegistration can be implemented.
 827 int UtcDaliTypeRegistryTypeRegistrationForNamedTypeP(void)
 828 {
 829   TestApplication application;
 830
 831   // Create Named Actor Type
 832   TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyNamedActor" );
 833   DALI_TEST_CHECK( type );
 834
 835   BaseHandle namedHandle = type.CreateInstance();
 836   DALI_TEST_CHECK( namedHandle );
 837   Actor namedActor( Actor::DownCast( namedHandle ) );
 838   DALI_TEST_CHECK( namedActor );
 839
 840   DALI_TEST_CHECK( namedActor.GetName() == "NamedActor" );
 841   DALI_TEST_CHECK( type.GetName() == "MyNamedActor" );
 842   DALI_TEST_CHECK( type.GetBaseName() == "Actor" );
 843
 844   END_TEST;
 845 }
 846
 847 int UtcDaliTypeRegistryRegisteredNameP(void)
 848 {
 849   TestApplication application;
 850
 851   DALI_TEST_CHECK( scriptedName == scriptedType.RegisteredName() );
 852
 853   TypeInfo baseType = TypeRegistry::Get().GetTypeInfo( scriptedName );
 854   DALI_TEST_CHECK( baseType );
 855
 856   BaseHandle handle = baseType.CreateInstance();
 857
 858   DALI_TEST_CHECK( true == CreateCustomNamedInitCalled );
 859   TypeInfo type = TypeRegistry::Get().GetTypeInfo( scriptedName );
 860   DALI_TEST_CHECK( type );
 861   END_TEST;
 862 }
 863
 864
 865 int UtcDaliTypeRegistryRegisteredNameN(void)
 866 {
 867   TestApplication application;
 868
 869   DALI_TEST_CHECK( scriptedName == scriptedType.RegisteredName() );
 870
 871   TypeInfo baseType = TypeRegistry::Get().GetTypeInfo( scriptedName );
 872   DALI_TEST_CHECK( baseType );
 873
 874   // should cause an assert because we're registering same type twice
 875   // once statically at the start of this file, then again now
 876   try
 877   {
 878     TypeRegistration scriptedType( scriptedName, typeid(Dali::CustomActor), CreateCustomNamedInit );
 879     tet_result( TET_FAIL );
 880   }
 881   catch ( DaliException& e )
 882   {
 883     DALI_TEST_ASSERT( e, "Duplicate type name for Type Registation", TEST_LOCATION );
 884   }
 885
 886   END_TEST;
 887 }
 888
 889
 890 int UtcDaliTypeRegistrySignalConnectorTypeP(void)
 891 {
 892   ResetFunctorCounts();
 893
 894   TestApplication application;
 895
 896   TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor" );
 897   DALI_TEST_CHECK( type );
 898
 899   BaseHandle handle = type.CreateInstance();
 900   DALI_TEST_CHECK( handle );
 901
 902   MyTestCustomActor customHandle = MyTestCustomActor::DownCast( handle );
 903   DALI_TEST_CHECK( customHandle );
 904
 905   {
 906     TestConnectionTracker tracker;
 907
 908     bool connected = handle.ConnectSignal( &tracker, "sig1", CustomTestFunctor() );
 909     DALI_TEST_EQUALS( connected, true, TEST_LOCATION );
 910     DALI_TEST_CHECK( lastSignalConnectionCustom == "sig1" );
 911     DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
 912     DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION );
 913
 914     DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION );
 915     customHandle.GetCustomSignal().Emit();
 916     DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION );
 917     DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
 918     DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION );
 919   }
 920   // tracker should automatically disconnect here
 921   DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
 922   DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION );
 923
 924   // Test that functor is disconnected
 925   DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION );
 926   customHandle.GetCustomSignal().Emit();
 927   DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1/*not incremented*/, TEST_LOCATION );
 928   DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
 929   DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION );
 930
 931   END_TEST;
 932 }
 933
 934 int UtcDaliTypeRegistrySignalConnectorTypeN(void)
 935 {
 936   // Test what happens when signal connnector (DoConnectSignalFailure method) returns false
 937
 938   ResetFunctorCounts();
 939
 940   TestApplication application;
 941
 942   TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor" );
 943   DALI_TEST_CHECK( type );
 944
 945   TypeInfo baseType = TypeRegistry::Get().GetTypeInfo( "CustomActor" );
 946   DALI_TEST_CHECK( baseType );
 947
 948   BaseHandle handle = type.CreateInstance();
 949   DALI_TEST_CHECK( handle );
 950
 951   MyTestCustomActor customHandle = MyTestCustomActor::DownCast( handle );
 952   DALI_TEST_CHECK( customHandle );
 953
 954   DALI_TEST_EQUALS( type.GetActionCount(), TEST_ACTION_COUNT + baseType.GetActionCount(), TEST_LOCATION );
 955
 956   DALI_TEST_EQUALS( type.GetSignalCount(), TEST_SIGNAL_COUNT + baseType.GetSignalCount(), TEST_LOCATION );
 957
 958   {
 959     TestConnectionTracker tracker;
 960
 961     bool connected = handle.ConnectSignal( &tracker, "sig2", CustomTestFunctor() );
 962     DALI_TEST_EQUALS( connected, false/*This is supposed to fail*/, TEST_LOCATION );
 963     DALI_TEST_CHECK( lastSignalConnectionCustom == "failed" );
 964     DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
 965     DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 0/*deleted along with FunctorDelegate*/, TEST_LOCATION );
 966
 967     // Should be a NOOP
 968     DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION );
 969     customHandle.GetCustomSignal().Emit();
 970     DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0/*never called*/, TEST_LOCATION );
 971   }
 972   // tracker should have nothing to disconnect here
 973
 974   // Should be a NOOP
 975   DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION );
 976   customHandle.GetCustomSignal().Emit();
 977   DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0/*never called*/, TEST_LOCATION );
 978   END_TEST;
 979 }
 980
 981 int UtcDaliTypeRegistryTypeActionP(void)
 982 {
 983   ResetFunctorCounts();
 984
 985   TestApplication application;
 986
 987   TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor" );
 988   DALI_TEST_CHECK( type );
 989
 990   BaseHandle handle = type.CreateInstance();
 991   DALI_TEST_CHECK( handle );
 992
 993   Property::Map attributes;
 994   DALI_TEST_CHECK( handle.DoAction("act1", attributes) );
 995   DALI_TEST_CHECK( lastActionCustom == "act1" );
 996
 997   END_TEST;
 998 }
 999
1000 int UtcDaliTypeRegistryTypeActionN(void)
1001 {
1002   ResetFunctorCounts();
1003
1004   TestApplication application;
1005
1006   TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor" );
1007   DALI_TEST_CHECK( type );
1008
1009   BaseHandle handle = type.CreateInstance();
1010   DALI_TEST_CHECK( handle );
1011
1012   Property::Map attributes;
1013   DALI_TEST_CHECK( !handle.DoAction( "unknownAction",  attributes ) );
1014
1015   END_TEST;
1016 }
1017
1018 int UtcDaliTypeRegistryPropertyRegistrationP(void)
1019 {
1020   TestApplication application;
1021   TypeRegistry typeRegistry = TypeRegistry::Get();
1022
1023   // Check property count before property registration
1024   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
1025   DALI_TEST_CHECK( typeInfo );
1026   BaseHandle handle = typeInfo.CreateInstance();
1027   DALI_TEST_CHECK( handle );
1028   Actor customActor = Actor::DownCast( handle );
1029   DALI_TEST_CHECK( customActor );
1030   unsigned int initialPropertyCount( customActor.GetPropertyCount() );
1031
1032   std::string propertyName( "prop1" );
1033   int propertyIndex( PROPERTY_REGISTRATION_START_INDEX );
1034   Property::Type propertyType( Property::BOOLEAN );
1035   PropertyRegistration property1( customType1, propertyName, propertyIndex, propertyType, &SetProperty, &GetProperty );
1036
1037   // Check property count after registration
1038   unsigned int postRegistrationPropertyCount( customActor.GetPropertyCount() );
1039   DALI_TEST_EQUALS( initialPropertyCount + 1u, postRegistrationPropertyCount, TEST_LOCATION );
1040
1041   // Add custom property and check property count
1042   customActor.RegisterProperty( "customProp1",   true );
1043   unsigned int customPropertyCount( customActor.GetPropertyCount() );
1044   DALI_TEST_EQUALS( postRegistrationPropertyCount + 1u, customPropertyCount, TEST_LOCATION );
1045
1046   // Set the property, ensure SetProperty called
1047   DALI_TEST_CHECK( !setPropertyCalled );
1048   customActor.SetProperty( propertyIndex, false );
1049   DALI_TEST_CHECK( setPropertyCalled );
1050
1051   // Get the property, ensure GetProperty called
1052   DALI_TEST_CHECK( !getPropertyCalled );
1053   (void)customActor.GetProperty< bool >( propertyIndex );
1054   DALI_TEST_CHECK( getPropertyCalled );
1055
1056   // Get the property using GetCurrentProperty and ensure GetProperty is called
1057   getPropertyCalled = false;
1058   DALI_TEST_CHECK( !getPropertyCalled );
1059   customActor.GetCurrentProperty< bool >( propertyIndex );
1060   DALI_TEST_CHECK( getPropertyCalled );
1061
1062   // Check the property name
1063   DALI_TEST_EQUALS( customActor.GetPropertyName( propertyIndex ), propertyName, TEST_LOCATION );
1064   DALI_TEST_EQUALS( typeInfo.GetPropertyName( propertyIndex ), propertyName, TEST_LOCATION );
1065
1066   // Check the property index
1067   DALI_TEST_EQUALS( customActor.GetPropertyIndex( propertyName ), propertyIndex, TEST_LOCATION );
1068
1069   // Check the property type
1070   DALI_TEST_EQUALS( customActor.GetPropertyType( propertyIndex ), propertyType, TEST_LOCATION );
1071
1072   // Check property count of type-info is 1
1073   Property::IndexContainer indices;
1074   typeInfo.GetPropertyIndices( indices );
1075
1076   size_t typePropertyCount = typeInfo.GetPropertyCount();
1077   DALI_TEST_EQUALS( indices.Size(), 1u, TEST_LOCATION );
1078   DALI_TEST_EQUALS( indices.Size(), typePropertyCount, TEST_LOCATION );
1079
1080   // Ensure indices returned from actor and customActor differ by two
1081   Actor actor = Actor::New();
1082   actor.GetPropertyIndices( indices );
1083   unsigned int actorIndices = indices.Size();
1084   customActor.GetPropertyIndices( indices );
1085   unsigned int customActorIndices = indices.Size();
1086   DALI_TEST_EQUALS( actorIndices + 2u, customActorIndices, TEST_LOCATION ); // Custom property + registered property
1087   END_TEST;
1088 }
1089
1090 int UtcDaliTypeRegistryPropertyRegistrationN(void)
1091 {
1092   TestApplication application;
1093   TypeRegistry typeRegistry = TypeRegistry::Get();
1094
1095   // Attempt to register a property type out-of-bounds index (less than)
1096   try
1097   {
1098     PropertyRegistration property1( customType1, "propName",  PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN, &SetProperty, &GetProperty );
1099     tet_result( TET_FAIL );
1100   }
1101   catch ( DaliException& e )
1102   {
1103     DALI_TEST_ASSERT( e, "( index >= PROPERTY_REGISTRATION_START_INDEX ) && ( index <= PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1104   }
1105
1106   // Attempt to register a property type out-of-bounds index (greater than)
1107   try
1108   {
1109     PropertyRegistration property1( customType1, "propName",  PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN, &SetProperty, &GetProperty );
1110     tet_result( TET_FAIL );
1111   }
1112   catch ( DaliException& e )
1113   {
1114     DALI_TEST_ASSERT( e, "( index >= PROPERTY_REGISTRATION_START_INDEX ) && ( index <= PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1115   }
1116
1117   END_TEST;
1118 }
1119
1120 int UtcDaliTypeRegistryAnimatablePropertyRegistrationP(void)
1121 {
1122   TestApplication application;
1123   TypeRegistry typeRegistry = TypeRegistry::Get();
1124
1125   // Check property count before property registration
1126   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
1127   DALI_TEST_CHECK( typeInfo );
1128   BaseHandle handle = typeInfo.CreateInstance();
1129   DALI_TEST_CHECK( handle );
1130   Actor customActor = Actor::DownCast( handle );
1131   DALI_TEST_CHECK( customActor );
1132   Stage::GetCurrent().Add(customActor);
1133
1134   unsigned int customPropertyCount( customActor.GetPropertyCount() );
1135
1136   // Register animatable property
1137   std::string animatablePropertyName( "animatableProp1" );
1138   int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
1139   Property::Type animatablePropertyType( Property::FLOAT );
1140   AnimatablePropertyRegistration animatableProperty( customType1, animatablePropertyName, animatablePropertyIndex, animatablePropertyType );
1141
1142   // Check property count after registration
1143   DALI_TEST_EQUALS( customPropertyCount + 1u, customActor.GetPropertyCount(), TEST_LOCATION );
1144
1145   // Set the animatable property value
1146   customActor.SetProperty( animatablePropertyIndex, 25.0f );
1147
1148   // Render and notify
1149   application.SendNotification();
1150   application.Render();
1151
1152   // Check the animatable property value
1153   DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 25.f, TEST_LOCATION );
1154
1155   // Check the animatable property name
1156   DALI_TEST_EQUALS( customActor.GetPropertyName( animatablePropertyIndex ), animatablePropertyName, TEST_LOCATION );
1157
1158   // Check the animatable property index
1159   DALI_TEST_EQUALS( customActor.GetPropertyIndex( animatablePropertyName ), animatablePropertyIndex, TEST_LOCATION );
1160
1161   // Check the animatable property type
1162   DALI_TEST_EQUALS( customActor.GetPropertyType( animatablePropertyIndex ), animatablePropertyType, TEST_LOCATION );
1163
1164   // Check property count of type-info is 1
1165   Property::IndexContainer indices;
1166   typeInfo.GetPropertyIndices( indices );
1167   DALI_TEST_EQUALS( indices.Size(), 1u, TEST_LOCATION );
1168
1169   // Ensure indices returned from actor and customActor differ by one
1170   Actor actor = Actor::New();
1171   actor.GetPropertyIndices( indices );
1172   unsigned int actorIndices = indices.Size();
1173   customActor.GetPropertyIndices( indices );
1174   unsigned int customActorIndices = indices.Size();
1175   DALI_TEST_EQUALS( actorIndices + 1u, customActorIndices, TEST_LOCATION ); // Custom property + registered property
1176
1177   // check that the property is animatable
1178   Animation animation = Animation::New(0.2f);
1179   animation.AnimateTo( Property( customActor, animatablePropertyIndex ), 15.f, AlphaFunction::LINEAR );
1180   animation.Play();
1181
1182   // Target value should change straight away
1183   DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 15.0f, TEST_LOCATION );
1184
1185   // Render and notify, animation play for 0.05 seconds
1186   application.SendNotification();
1187   application.Render(50);
1188   DALI_TEST_EQUALS( 0.25f, animation.GetCurrentProgress(), TEST_LOCATION );
1189   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 22.5f, TEST_LOCATION );
1190
1191   // Render and notify, animation play for another 0.1 seconds
1192   application.SendNotification();
1193   application.Render(100);
1194   DALI_TEST_EQUALS( 0.75f, animation.GetCurrentProgress(), TEST_LOCATION );
1195   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 17.5f, TEST_LOCATION );
1196
1197   END_TEST;
1198 }
1199
1200 int UtcDaliTypeRegistryAnimatablePropertyRegistrationN(void)
1201 {
1202   TestApplication application;
1203   TypeRegistry typeRegistry = TypeRegistry::Get();
1204
1205   // Attempt to register an animatable property type out-of-bounds index (less than)
1206   try
1207   {
1208     AnimatablePropertyRegistration property1( customType1, "animPropName",   ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN );
1209     tet_result( TET_FAIL );
1210   }
1211   catch ( DaliException& e )
1212   {
1213     DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1214   }
1215
1216   // Attempt to register an animatable property type out-of-bounds index (greater than)
1217   try
1218   {
1219     AnimatablePropertyRegistration property1( customType1, "animPropName",   ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN );
1220     tet_result( TET_FAIL );
1221   }
1222   catch ( DaliException& e )
1223   {
1224     DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1225   }
1226
1227   END_TEST;
1228 }
1229
1230 int UtcDaliTypeRegistryAnimatablePropertyRegistrationWithDefaultP(void)
1231 {
1232   TestApplication application;
1233   TypeRegistry typeRegistry = TypeRegistry::Get();
1234
1235   // Check property count before property registration
1236   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
1237   DALI_TEST_CHECK( typeInfo );
1238   BaseHandle handle = typeInfo.CreateInstance();
1239   DALI_TEST_CHECK( handle );
1240   Actor customActor = Actor::DownCast( handle );
1241   DALI_TEST_CHECK( customActor );
1242   Stage::GetCurrent().Add(customActor);
1243
1244   unsigned int customPropertyCount( customActor.GetPropertyCount() );
1245
1246   // Register animatable property
1247   std::string animatablePropertyName( "animatableProp1" );
1248   int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
1249   AnimatablePropertyRegistration animatableProperty1( customType1, animatablePropertyName, animatablePropertyIndex, 10.f );
1250
1251   // Check property count after registration
1252   DALI_TEST_EQUALS( customPropertyCount + 1u, customActor.GetPropertyCount(), TEST_LOCATION );
1253
1254   // Render and notify
1255   application.SendNotification();
1256   application.Render();
1257
1258   // Check the animatable property value
1259   DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 10.f, TEST_LOCATION );
1260
1261   // Check the animatable property name
1262   DALI_TEST_EQUALS( customActor.GetPropertyName( animatablePropertyIndex ), animatablePropertyName, TEST_LOCATION );
1263
1264   // Check the animatable property index
1265   DALI_TEST_EQUALS( customActor.GetPropertyIndex( animatablePropertyName ), animatablePropertyIndex, TEST_LOCATION );
1266
1267   // Check the animatable property type
1268   DALI_TEST_EQUALS( customActor.GetPropertyType( animatablePropertyIndex ), Property::FLOAT, TEST_LOCATION );
1269
1270   // Check property count of type-info is 1
1271   Property::IndexContainer indices;
1272   typeInfo.GetPropertyIndices( indices );
1273   DALI_TEST_EQUALS( indices.Size(), 1u, TEST_LOCATION );
1274
1275   // Ensure indices returned from actor and customActor differ by one
1276   Actor actor = Actor::New();
1277   actor.GetPropertyIndices( indices );
1278   unsigned int actorIndices = indices.Size();
1279   customActor.GetPropertyIndices( indices );
1280   unsigned int customActorIndices = indices.Size();
1281   DALI_TEST_EQUALS( actorIndices + 1u, customActorIndices, TEST_LOCATION ); // Custom property + registered property
1282
1283   // check that the property is animatable
1284   Animation animation = Animation::New(0.2f);
1285   animation.AnimateTo( Property( customActor, animatablePropertyIndex ), 20.f, AlphaFunction::LINEAR );
1286   animation.Play();
1287
1288   // Target value should change straight away
1289   DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 20.0f, TEST_LOCATION );
1290
1291   // Render and notify, animation play for 0.05 seconds
1292   application.SendNotification();
1293   application.Render(50);
1294   DALI_TEST_EQUALS( 0.25f, animation.GetCurrentProgress(), TEST_LOCATION );
1295   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 12.5f, TEST_LOCATION );
1296
1297   // Render and notify, animation play for another 0.1 seconds
1298   application.SendNotification();
1299   application.Render(100);
1300   DALI_TEST_EQUALS( 0.75f, animation.GetCurrentProgress(), TEST_LOCATION );
1301   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 17.5f, TEST_LOCATION );
1302
1303   END_TEST;
1304 }
1305
1306 int UtcDaliTypeRegistryAnimatablePropertyRegistrationWithDefaultN(void)
1307 {
1308   TestApplication application;
1309   TypeRegistry typeRegistry = TypeRegistry::Get();
1310
1311   // Attempt to register an animatable property type out-of-bounds index (less than)
1312   try
1313   {
1314     AnimatablePropertyRegistration property1( customType1, "animPropName",   ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, false );
1315     tet_result( TET_FAIL );
1316   }
1317   catch ( DaliException& e )
1318   {
1319     DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1320   }
1321
1322   // Attempt to register an animatable property type out-of-bounds index (greater than)
1323   try
1324   {
1325     AnimatablePropertyRegistration property1( customType1, "animPropName",   ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, true );
1326     tet_result( TET_FAIL );
1327   }
1328   catch ( DaliException& e )
1329   {
1330     DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1331   }
1332
1333   END_TEST;
1334 }
1335
1336 int UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationP(void)
1337 {
1338   TestApplication application;
1339   TypeRegistry typeRegistry = TypeRegistry::Get();
1340
1341   // Check property count before property registration
1342   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
1343   DALI_TEST_CHECK( typeInfo );
1344   BaseHandle handle = typeInfo.CreateInstance();
1345   DALI_TEST_CHECK( handle );
1346   Actor customActor = Actor::DownCast( handle );
1347   DALI_TEST_CHECK( customActor );
1348
1349   unsigned int customPropertyCount( customActor.GetPropertyCount() );
1350
1351   // Register animatable property
1352   std::string animatablePropertyName( "animatableProp1" );
1353   int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
1354   Property::Type animatablePropertyType( Property::VECTOR2 );
1355   AnimatablePropertyRegistration animatableProperty1( customType1, animatablePropertyName, animatablePropertyIndex, animatablePropertyType );
1356
1357   // Check property count after registration
1358   DALI_TEST_EQUALS( customPropertyCount + 1u, customActor.GetPropertyCount(), TEST_LOCATION );
1359
1360   // Set the animatable property value
1361   customActor.SetProperty( animatablePropertyIndex, Vector2(25.0f, 50.0f) );
1362
1363   // Render and notify
1364   application.SendNotification();
1365   application.Render();
1366
1367   // Check the animatable property value
1368   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( animatablePropertyIndex ), Vector2(25.0f, 50.0f), TEST_LOCATION );
1369
1370   // Check the animatable property name
1371   DALI_TEST_EQUALS( customActor.GetPropertyName( animatablePropertyIndex ), animatablePropertyName, TEST_LOCATION );
1372
1373   // Check the animatable property index
1374   DALI_TEST_EQUALS( customActor.GetPropertyIndex( animatablePropertyName ), animatablePropertyIndex, TEST_LOCATION );
1375
1376   // Check the animatable property type
1377   DALI_TEST_EQUALS( customActor.GetPropertyType( animatablePropertyIndex ), animatablePropertyType, TEST_LOCATION );
1378
1379   // Check property count of type-info is 1
1380   Property::IndexContainer indices;
1381   typeInfo.GetPropertyIndices( indices );
1382   DALI_TEST_EQUALS( indices.Size(), 1u, TEST_LOCATION );
1383
1384   // Register animatable property components
1385   std::string animatablePropertyComponentName1( "animatableProp1X" );
1386   int animatablePropertyComponentIndex1( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1 );
1387   AnimatablePropertyComponentRegistration animatablePropertyComponent1( customType1, animatablePropertyComponentName1, animatablePropertyComponentIndex1, animatablePropertyIndex, 0 );
1388
1389   std::string animatablePropertyComponentName2( "animatableProp1Y" );
1390   int animatablePropertyComponentIndex2( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2 );
1391   AnimatablePropertyComponentRegistration animatablePropertyComponent2( customType1, animatablePropertyComponentName2, animatablePropertyComponentIndex2, animatablePropertyIndex, 1 );
1392
1393   // Check property count after registration
1394   DALI_TEST_EQUALS( customPropertyCount + 3u, customActor.GetPropertyCount(), TEST_LOCATION );
1395
1396   // Check the animatable property component value
1397   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex1 ), 25.0f, TEST_LOCATION );
1398   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex2 ), 50.0f, TEST_LOCATION );
1399
1400   // Set the animatable property component value
1401   customActor.SetProperty( animatablePropertyComponentIndex1, 150.0f );
1402
1403   // Render and notify
1404   application.SendNotification();
1405   application.Render();
1406
1407   // Check the animatable property value
1408   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( animatablePropertyIndex ), Vector2(150.0f, 50.0f), TEST_LOCATION );
1409   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex1 ), 150.0f, TEST_LOCATION );
1410   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex2 ), 50.0f, TEST_LOCATION );
1411
1412   // Set the animatable property component value
1413   customActor.SetProperty( animatablePropertyComponentIndex2, 225.0f );
1414
1415   // Render and notify
1416   application.SendNotification();
1417   application.Render();
1418
1419   // Check the animatable property value
1420   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( animatablePropertyIndex ), Vector2(150.0f, 225.0f), TEST_LOCATION );
1421   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex1 ), 150.0f, TEST_LOCATION );
1422   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex2 ), 225.0f, TEST_LOCATION );
1423
1424   // Ensure indices returned from actor and customActor differ by three
1425   Actor actor = Actor::New();
1426   actor.GetPropertyIndices( indices );
1427   unsigned int actorIndices = indices.Size();
1428   customActor.GetPropertyIndices( indices );
1429   unsigned int customActorIndices = indices.Size();
1430   DALI_TEST_EQUALS( actorIndices + 3u, customActorIndices, TEST_LOCATION ); // Custom property + registered property
1431
1432   END_TEST;
1433 }
1434
1435 int UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationVector2AnimateByP(void)
1436 {
1437   TestApplication application;
1438   TypeRegistry typeRegistry = TypeRegistry::Get();
1439
1440   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
1441   DALI_TEST_CHECK( typeInfo );
1442   BaseHandle handle = typeInfo.CreateInstance();
1443   DALI_TEST_CHECK( handle );
1444   Actor customActor = Actor::DownCast( handle );
1445   DALI_TEST_CHECK( customActor );
1446
1447   const unsigned int index = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX;
1448   const unsigned int xComponentIndex = index + 1;
1449   const unsigned int yComponentIndex = index + 2;
1450   const Vector2 initialValue( 20.0f, 40.0f );
1451
1452   // Register animatable property & its components
1453   AnimatablePropertyRegistration animatableProperty1( customType1, "animatableProp1", index, initialValue );
1454   AnimatablePropertyComponentRegistration animatablePropertyComponent1( customType1, "animatableProp1X", xComponentIndex, index, 0 );
1455   AnimatablePropertyComponentRegistration animatablePropertyComponent2( customType1, "animatableProp1Y", yComponentIndex, index, 1 );
1456
1457   // Check the animatable property value
1458   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( index ), initialValue, TEST_LOCATION );
1459   DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
1460   DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
1461
1462   // Render and notify
1463   application.SendNotification();
1464   application.Render();
1465
1466   // Check the animatable property current value
1467   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( index ), initialValue, TEST_LOCATION );
1468   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
1469   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
1470
1471   // Do an AnimateBy
1472   const Vector2 targetValue( 45.0f, 53.0f );
1473   const Vector2 relativeValue( targetValue - initialValue );
1474
1475   Animation animation = Animation::New( 1.0f );
1476   animation.AnimateBy( Property( customActor, xComponentIndex ), relativeValue.x );
1477   animation.AnimateBy( Property( customActor, yComponentIndex ), relativeValue.y );
1478   animation.Play();
1479
1480   // Target values should change straight away
1481   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
1482   DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), targetValue.x, TEST_LOCATION );
1483   DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), targetValue.y, TEST_LOCATION );
1484
1485   END_TEST;
1486 }
1487
1488 int UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationVector3AnimateByP(void)
1489 {
1490   TestApplication application;
1491   TypeRegistry typeRegistry = TypeRegistry::Get();
1492
1493   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
1494   DALI_TEST_CHECK( typeInfo );
1495   BaseHandle handle = typeInfo.CreateInstance();
1496   DALI_TEST_CHECK( handle );
1497   Actor customActor = Actor::DownCast( handle );
1498   DALI_TEST_CHECK( customActor );
1499
1500   const unsigned int index = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX;
1501   const unsigned int xComponentIndex = index + 1;
1502   const unsigned int yComponentIndex = index + 2;
1503   const unsigned int zComponentIndex = index + 3;
1504   const Vector3 initialValue( 20.0f, 40.0f, 50.0f );
1505
1506   // Register animatable property & its components
1507   AnimatablePropertyRegistration animatableProperty1( customType1, "animatableProp1", index, initialValue );
1508   AnimatablePropertyComponentRegistration animatablePropertyComponent1( customType1, "animatableProp1X", xComponentIndex, index, 0 );
1509   AnimatablePropertyComponentRegistration animatablePropertyComponent2( customType1, "animatableProp1Y", yComponentIndex, index, 1 );
1510   AnimatablePropertyComponentRegistration animatablePropertyComponent3( customType1, "animatableProp1Z", zComponentIndex, index, 2 );
1511
1512   // Check the animatable property value
1513   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( index ), initialValue, TEST_LOCATION );
1514   DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
1515   DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
1516   DALI_TEST_EQUALS( customActor.GetProperty< float >( zComponentIndex ), initialValue.z, TEST_LOCATION );
1517
1518   // Render and notify
1519   application.SendNotification();
1520   application.Render();
1521
1522   // Check the animatable property current value
1523   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector3 >( index ), initialValue, TEST_LOCATION );
1524   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
1525   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
1526   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( zComponentIndex ), initialValue.z, TEST_LOCATION );
1527
1528   // Do an AnimateBy
1529   const Vector3 targetValue( 45.0f, 53.0f, 25.0f );
1530   const Vector3 relativeValue( targetValue - initialValue );
1531
1532   Animation animation = Animation::New( 1.0f );
1533   animation.AnimateBy( Property( customActor, xComponentIndex ), relativeValue.x );
1534   animation.AnimateBy( Property( customActor, yComponentIndex ), relativeValue.y );
1535   animation.AnimateBy( Property( customActor, zComponentIndex ), relativeValue.z );
1536   animation.Play();
1537
1538   // Target values should change straight away
1539   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
1540   DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), targetValue.x, TEST_LOCATION );
1541   DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), targetValue.y, TEST_LOCATION );
1542   DALI_TEST_EQUALS( customActor.GetProperty< float >( zComponentIndex ), targetValue.z, TEST_LOCATION );
1543
1544   END_TEST;
1545 }
1546
1547 int UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationVector4AnimateByP(void)
1548 {
1549   TestApplication application;
1550   TypeRegistry typeRegistry = TypeRegistry::Get();
1551
1552   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
1553   DALI_TEST_CHECK( typeInfo );
1554   BaseHandle handle = typeInfo.CreateInstance();
1555   DALI_TEST_CHECK( handle );
1556   Actor customActor = Actor::DownCast( handle );
1557   DALI_TEST_CHECK( customActor );
1558
1559   const unsigned int index = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX;
1560   const unsigned int xComponentIndex = index + 1;
1561   const unsigned int yComponentIndex = index + 2;
1562   const unsigned int zComponentIndex = index + 3;
1563   const unsigned int wComponentIndex = index + 4;
1564   const Vector4 initialValue( 20.0f, 40.0f, 50.0f, 60.0f );
1565
1566   // Register animatable property & its components
1567   AnimatablePropertyRegistration animatableProperty1( customType1, "animatableProp1", index, initialValue );
1568   AnimatablePropertyComponentRegistration animatablePropertyComponent1( customType1, "animatableProp1X", xComponentIndex, index, 0 );
1569   AnimatablePropertyComponentRegistration animatablePropertyComponent2( customType1, "animatableProp1Y", yComponentIndex, index, 1 );
1570   AnimatablePropertyComponentRegistration animatablePropertyComponent3( customType1, "animatableProp1Z", zComponentIndex, index, 2 );
1571   AnimatablePropertyComponentRegistration animatablePropertyComponent4( customType1, "animatableProp1W", wComponentIndex, index, 3 );
1572
1573   // Check the animatable property value
1574   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( index ), initialValue, TEST_LOCATION );
1575   DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
1576   DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
1577   DALI_TEST_EQUALS( customActor.GetProperty< float >( zComponentIndex ), initialValue.z, TEST_LOCATION );
1578   DALI_TEST_EQUALS( customActor.GetProperty< float >( wComponentIndex ), initialValue.w, TEST_LOCATION );
1579
1580   // Render and notify
1581   application.SendNotification();
1582   application.Render();
1583
1584   // Check the animatable property current value
1585   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector4 >( index ), initialValue, TEST_LOCATION );
1586   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
1587   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
1588   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( zComponentIndex ), initialValue.z, TEST_LOCATION );
1589   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( wComponentIndex ), initialValue.w, TEST_LOCATION );
1590
1591   // Do an AnimateBy
1592   const Vector4 targetValue( 45.0f, 53.0f, 25.0f, 13.0f );
1593   const Vector4 relativeValue( targetValue - initialValue );
1594
1595   Animation animation = Animation::New( 1.0f );
1596   animation.AnimateBy( Property( customActor, xComponentIndex ), relativeValue.x );
1597   animation.AnimateBy( Property( customActor, yComponentIndex ), relativeValue.y );
1598   animation.AnimateBy( Property( customActor, zComponentIndex ), relativeValue.z );
1599   animation.AnimateBy( Property( customActor, wComponentIndex ), relativeValue.w );
1600   animation.Play();
1601
1602   // Target values should change straight away
1603   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
1604   DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), targetValue.x, TEST_LOCATION );
1605   DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), targetValue.y, TEST_LOCATION );
1606   DALI_TEST_EQUALS( customActor.GetProperty< float >( zComponentIndex ), targetValue.z, TEST_LOCATION );
1607   DALI_TEST_EQUALS( customActor.GetProperty< float >( wComponentIndex ), targetValue.w, TEST_LOCATION );
1608
1609   END_TEST;
1610 }
1611
1612 int UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationN(void)
1613 {
1614   TestApplication application;
1615   TypeRegistry typeRegistry = TypeRegistry::Get();
1616
1617   // Register animatable property with the type of Vector2
1618   int animatablePropertyIndex1( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
1619   AnimatablePropertyRegistration animatableProperty1( customType1, "animatableProp1",   animatablePropertyIndex1, Property::VECTOR2 );
1620
1621   // Attempt to register an animatable property component out-of-bounds index (less than)
1622   try
1623   {
1624     AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X",    ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, animatablePropertyIndex1, 0 );
1625     tet_result( TET_FAIL );
1626   }
1627   catch ( DaliException& e )
1628   {
1629     DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1630   }
1631
1632   // Attempt to register an animatable property component out-of-bounds index (greater than)
1633   try
1634   {
1635     AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X",    ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, animatablePropertyIndex1, 0 );
1636     tet_result( TET_FAIL );
1637   }
1638   catch ( DaliException& e )
1639   {
1640     DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1641   }
1642
1643   // Register an animatable property component
1644   AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X",    ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1, animatablePropertyIndex1, 0 );
1645
1646   // Attempt to register another animatable property component with the same component index
1647   try
1648   {
1649     AnimatablePropertyComponentRegistration propertyComponent2( customType1, "animatableProp1Y",    ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2, animatablePropertyIndex1, 0 );
1650     tet_result( TET_FAIL );
1651   }
1652   catch ( DaliException& e )
1653   {
1654     DALI_TEST_ASSERT( e, "Property component already registered", TEST_LOCATION );
1655   }
1656
1657   // Register animatable property with the type of boolean
1658   int animatablePropertyIndex2( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2 );
1659   AnimatablePropertyRegistration animatableProperty2( customType1, "animatableProp2",   animatablePropertyIndex2, Property::BOOLEAN );
1660
1661   // Attempt to register an animatable property component for the above property with boolean type
1662   try
1663   {
1664     AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp2X",    animatablePropertyIndex2 + 1, animatablePropertyIndex2, 0 );
1665     tet_result( TET_FAIL );
1666   }
1667   catch ( DaliException& e )
1668   {
1669     DALI_TEST_ASSERT( e, "Base property does not support component", TEST_LOCATION );
1670   }
1671
1672   END_TEST;
1673 }
1674
1675 int UtcDaliTypeRegistryChildPropertyRegistrationP(void)
1676 {
1677   TestApplication application;
1678   TypeRegistry typeRegistry = TypeRegistry::Get();
1679
1680   // Check property count before property registration
1681   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
1682   DALI_TEST_CHECK( typeInfo );
1683   BaseHandle handle = typeInfo.CreateInstance();
1684   DALI_TEST_CHECK( handle );
1685   Actor customActor = Actor::DownCast( handle );
1686   DALI_TEST_CHECK( customActor );
1687   unsigned int initialPropertyCount( customActor.GetPropertyCount() );
1688
1689   // Register child properties to the parent
1690   std::string propertyName( "childProp1" );
1691   int propertyIndex( CHILD_PROPERTY_REGISTRATION_START_INDEX );
1692   Property::Type propertyType( Property::BOOLEAN );
1693   ChildPropertyRegistration childProperty1( customType1, propertyName, propertyIndex, propertyType );
1694
1695   std::string propertyName2( "childProp2" );
1696   int propertyIndex2( CHILD_PROPERTY_REGISTRATION_START_INDEX + 1 );
1697   Property::Type propertyType2( Property::INTEGER );
1698   ChildPropertyRegistration childProperty2( customType1, propertyName2, propertyIndex2, propertyType2 );
1699
1700   std::string propertyName3( "childProp3" );
1701   int propertyIndex3( CHILD_PROPERTY_REGISTRATION_START_INDEX + 2 );
1702   Property::Type propertyType3( Property::FLOAT );
1703   ChildPropertyRegistration childProperty3( customType1, propertyName3, propertyIndex3, propertyType3 );
1704
1705   std::string propertyName4( "childProp4" );
1706   int propertyIndex4( CHILD_PROPERTY_REGISTRATION_START_INDEX + 3 );
1707   Property::Type propertyType4( Property::INTEGER );
1708   ChildPropertyRegistration childProperty4( customType1, propertyName4, propertyIndex4, propertyType4 );
1709
1710   // Check property count are not changed because the child properties will not be created for the parent
1711   DALI_TEST_EQUALS( initialPropertyCount, customActor.GetPropertyCount(), TEST_LOCATION );
1712
1713   // check the child property type
1714   Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
1715   Property::Type type = typeInfoImpl.GetChildPropertyType( typeInfoImpl.GetChildPropertyIndex("childProp4") );
1716   DALI_TEST_EQUALS( type, Property::INTEGER, TEST_LOCATION );
1717
1718
1719   // Create a child actor
1720   Actor childActor = Actor::New();
1721   DALI_TEST_CHECK( childActor );
1722   unsigned int initialChildActorPropertyCount( childActor.GetPropertyCount() );
1723
1724   // The type of child properties should be Property::None as the child hasn't registered any child property yet.
1725   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex ), Property::NONE, TEST_LOCATION );
1726   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex2 ), Property::NONE, TEST_LOCATION );
1727   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex3 ), Property::NONE, TEST_LOCATION );
1728   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex4 ), Property::NONE, TEST_LOCATION );
1729
1730   // Set the value for the first child property when the child actor doesn't have a parent yet
1731   childActor.SetProperty(propertyIndex, true);
1732
1733   // Check that the first child property is dynamically created
1734   DALI_TEST_EQUALS( initialChildActorPropertyCount + 1u, childActor.GetPropertyCount(), TEST_LOCATION );
1735
1736   // Check the first child property value
1737   DALI_TEST_EQUALS( childActor.GetProperty< bool >( propertyIndex ), true, TEST_LOCATION );
1738
1739   // Check the first child property type
1740   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex ), propertyType, TEST_LOCATION );
1741
1742   // Check that the first child property have no name, as it doesn't have a parent yet.
1743   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex ), "", TEST_LOCATION );
1744
1745   // Check that the first property can't be accessed through its name, as it doesn't have a parent yet.
1746   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName ), Property::INVALID_INDEX, TEST_LOCATION );
1747
1748   // Create a custom property for the child with the same name as the second child property registered to the parent
1749   Property::Index customPropertyIndex = childActor.RegisterProperty(propertyName2, 100, Property::READ_WRITE);
1750
1751   // Check that the custom property is created
1752   DALI_TEST_EQUALS( initialChildActorPropertyCount + 2u, childActor.GetPropertyCount(), TEST_LOCATION );
1753
1754   // Check the property value
1755   DALI_TEST_EQUALS( childActor.GetProperty< int >( customPropertyIndex ), 100, TEST_LOCATION );
1756
1757   // Check the property index
1758   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName2 ), customPropertyIndex, TEST_LOCATION );
1759
1760   // Check the property type
1761   DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex ), propertyType2, TEST_LOCATION );
1762
1763   // Check the property name
1764   DALI_TEST_EQUALS( childActor.GetPropertyName( customPropertyIndex ), propertyName2, TEST_LOCATION );
1765
1766   // Now add the child actor to the parent
1767   customActor.Add( childActor );
1768
1769   // Check that the first child property now has the correct name as previously registered to the parent
1770   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex ), propertyName, TEST_LOCATION );
1771
1772   // Check that the child property index for the first child property can now be retrieved through its child property name
1773   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName ), propertyIndex, TEST_LOCATION );
1774
1775   // Check that the second child property now has the correct index as previously registered to the parent
1776   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex2 ), propertyName2, TEST_LOCATION );
1777
1778   // Check that the second child property can be accessed through both its custom property index and its child property index
1779   DALI_TEST_EQUALS( childActor.GetProperty< int >( customPropertyIndex ), 100, TEST_LOCATION );
1780   DALI_TEST_EQUALS( childActor.GetProperty< int >( propertyIndex2 ), 100, TEST_LOCATION );
1781   DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex ), propertyType2, TEST_LOCATION );
1782   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex2 ), propertyType2, TEST_LOCATION );
1783
1784   // Check that the child property index for the second child property can now be retrieved through its child property name
1785   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName2 ), propertyIndex2, TEST_LOCATION );
1786
1787   // Set the value for the third child property when the child actor is already added to the parent
1788   childActor.SetProperty(propertyIndex3, 0.15f);
1789
1790   // Check that the third child property is dynamically created
1791   DALI_TEST_EQUALS( initialChildActorPropertyCount + 3u, childActor.GetPropertyCount(), TEST_LOCATION );
1792
1793   // Check the third child property value
1794   DALI_TEST_EQUALS( childActor.GetProperty< float >( propertyIndex3 ), 0.15f, TEST_LOCATION );
1795
1796   // Check the third child property type
1797   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex3 ), propertyType3, TEST_LOCATION );
1798
1799   // Check the third child property name
1800   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex3 ), propertyName3, TEST_LOCATION );
1801
1802   // Check the third child property index.
1803   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName3 ), propertyIndex3, TEST_LOCATION );
1804
1805   // Create a custom property for the child with the same name as the fourth child property registered to the parent
1806   Property::Index customPropertyIndex2 = childActor.RegisterProperty(propertyName4, 20, Property::READ_WRITE);
1807
1808   // Check that the custom property is created
1809   DALI_TEST_EQUALS( initialChildActorPropertyCount + 4u, childActor.GetPropertyCount(), TEST_LOCATION );
1810
1811   // Check the fourth child property value
1812   DALI_TEST_EQUALS( childActor.GetProperty< int >( propertyIndex4 ), 20, TEST_LOCATION );
1813   DALI_TEST_EQUALS( childActor.GetProperty< int >( customPropertyIndex2 ), 20, TEST_LOCATION );
1814
1815   // Check the fourth child property type
1816   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex4 ), propertyType4, TEST_LOCATION );
1817   DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex2 ), propertyType4, TEST_LOCATION );
1818
1819   // Check the fourth child property name
1820   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex4 ), propertyName4, TEST_LOCATION );
1821   DALI_TEST_EQUALS( childActor.GetPropertyName( customPropertyIndex2 ), propertyName4, TEST_LOCATION );
1822
1823   // Check the fourth child property index.
1824   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName4 ), propertyIndex4, TEST_LOCATION );
1825
1826   // Now create another parent actor with different child properties registered
1827   TypeInfo typeInfo2 = typeRegistry.GetTypeInfo( "MyNamedActor" );
1828   DALI_TEST_CHECK( typeInfo2 );
1829   BaseHandle handle2 = typeInfo2.CreateInstance();
1830   DALI_TEST_CHECK( handle2 );
1831   Actor customActor2 = Actor::DownCast( handle2 );
1832   DALI_TEST_CHECK( customActor2 );
1833
1834   // Register child properties to the new parent
1835   std::string newPropertyName( "newChildProp" );
1836   int newPropertyIndex( CHILD_PROPERTY_REGISTRATION_START_INDEX ); // The same index as the first child property "childProp1" in the old parent
1837   Property::Type newPropertyType( Property::VECTOR2 );
1838   ChildPropertyRegistration newChildProperty( namedActorType, newPropertyName, newPropertyIndex, newPropertyType );
1839
1840   std::string newPropertyName2( "childProp3" ); // The same name as the third child property in the old parent
1841   int newPropertyIndex2( CHILD_PROPERTY_REGISTRATION_START_INDEX + 1 ); // The same index as the second child property "childProp2" in the old parent
1842   Property::Type newPropertyType2( Property::FLOAT ); // The same type as the third child property in the old parent
1843   ChildPropertyRegistration newChildProperty2( namedActorType, newPropertyName2, newPropertyIndex2, newPropertyType2 );
1844
1845   // Now move the child actor to the new parent
1846   customActor2.Add( childActor );
1847
1848   // "childProp1" is not a valid child property supported by the new parent, so nothing changed
1849   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex ), propertyType, TEST_LOCATION );
1850   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex ), propertyName, TEST_LOCATION );
1851   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName ), propertyIndex, TEST_LOCATION );
1852
1853   // "childProp3" is a valid child property supported by the new parent
1854   // So it should get its new child property index and should just work
1855   DALI_TEST_EQUALS( childActor.GetPropertyType( newPropertyIndex2 ), newPropertyType2, TEST_LOCATION );
1856   DALI_TEST_EQUALS( childActor.GetPropertyName( newPropertyIndex2 ), newPropertyName2, TEST_LOCATION );
1857   DALI_TEST_EQUALS( childActor.GetPropertyIndex( newPropertyName2 ), newPropertyIndex2, TEST_LOCATION );
1858   DALI_TEST_EQUALS( childActor.GetProperty< float >( newPropertyIndex2 ), 0.15f, TEST_LOCATION );
1859
1860   // Now register a custom property called "newChildProp"
1861   Property::Index customPropertyIndex3 = childActor.RegisterProperty("newChildProp", Vector2( 10.0f, 10.0f ), Property::READ_WRITE);
1862
1863   // Check that the custom property is created
1864   DALI_TEST_EQUALS( initialChildActorPropertyCount + 5u, childActor.GetPropertyCount(), TEST_LOCATION );
1865
1866   // This is a valid child property registered to the new parent
1867   // So should be able to access it through both its custom property index and its registered child property index
1868   DALI_TEST_EQUALS( childActor.GetPropertyType( newPropertyIndex ), newPropertyType, TEST_LOCATION );
1869   DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex3 ), newPropertyType, TEST_LOCATION );
1870   DALI_TEST_EQUALS( childActor.GetPropertyName( newPropertyIndex ), newPropertyName, TEST_LOCATION ); // This should return the new name, although the child property index remains the same
1871   DALI_TEST_EQUALS( childActor.GetPropertyName( customPropertyIndex3 ), newPropertyName, TEST_LOCATION );
1872   DALI_TEST_EQUALS( childActor.GetProperty< Vector2 >( newPropertyIndex ), Vector2( 10.0f, 10.0f ), TEST_LOCATION );
1873   DALI_TEST_EQUALS( childActor.GetProperty< Vector2 >( customPropertyIndex3 ), Vector2( 10.0f, 10.0f ), TEST_LOCATION );
1874
1875   // Should return the child property index by given its name
1876   DALI_TEST_EQUALS( childActor.GetPropertyIndex( newPropertyName ), newPropertyIndex, TEST_LOCATION );
1877
1878
1879   END_TEST;
1880 }
1881
1882 int UtcDaliTypeRegistryChildPropertyRegistrationN(void)
1883 {
1884   TestApplication application;
1885   TypeRegistry typeRegistry = TypeRegistry::Get();
1886
1887   // Attempt to register a child property type out-of-bounds index (less than)
1888   try
1889   {
1890     ChildPropertyRegistration property1( customType1, "propName",  CHILD_PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN );
1891     tet_result( TET_FAIL );
1892   }
1893   catch ( DaliException& e )
1894   {
1895     DALI_TEST_ASSERT( e, "( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1896   }
1897
1898   // Attempt to register a child property type out-of-bounds index (greater than)
1899   try
1900   {
1901     ChildPropertyRegistration property1( customType1, "propName",  CHILD_PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN );
1902     tet_result( TET_FAIL );
1903   }
1904   catch ( DaliException& e )
1905   {
1906     DALI_TEST_ASSERT( e, "( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1907   }
1908
1909   END_TEST;
1910 }
1911
1912
1913 /*******************************************************************************
1914  *
1915  * Action through the base handle
1916  *
1917  ******************************************************************************/
1918 int UtcDaliTypeRegistryActionViaBaseHandle(void)
1919 {
1920   TestApplication application;
1921
1922   TypeInfo type;
1923
1924   type = TypeRegistry::Get().GetTypeInfo( "Actor" );
1925   DALI_TEST_CHECK( type );
1926
1927   BaseHandle hdl = type.CreateInstance();
1928   DALI_TEST_CHECK( hdl );
1929
1930   Actor a = Actor::DownCast(hdl);
1931   DALI_TEST_CHECK( a );
1932
1933   a.SetVisible(false);
1934
1935   application.SendNotification();
1936   application.Render(0);
1937   DALI_TEST_CHECK(!a.IsVisible());
1938
1939   Property::Map attributes;
1940
1941   DALI_TEST_CHECK(hdl.DoAction("show", attributes));
1942
1943   application.SendNotification();
1944   application.Render(0);
1945   DALI_TEST_CHECK(a.IsVisible());
1946
1947   DALI_TEST_CHECK(!hdl.DoAction("unknownAction",  attributes));
1948   END_TEST;
1949 }
1950
1951 int UtcDaliPropertyRegistrationFunctions(void)
1952 {
1953   TestApplication application;
1954   int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 10;
1955
1956   // Attempt to register a property without a setter
1957   try
1958   {
1959     PropertyRegistration property1( customType1, "propName",  propertyIndex++, Property::BOOLEAN, NULL, &GetProperty );
1960     tet_result( TET_PASS );
1961   }
1962   catch ( DaliException& e )
1963   {
1964     tet_result( TET_FAIL );
1965   }
1966
1967   // Attempt to register a property without a getter
1968   try
1969   {
1970     PropertyRegistration property1( customType1, "propName",  propertyIndex++, Property::BOOLEAN, NULL, NULL );
1971     tet_result( TET_FAIL );
1972   }
1973   catch ( DaliException& e )
1974   {
1975     DALI_TEST_ASSERT( e, "! \"GetProperty", TEST_LOCATION );
1976   }
1977   END_TEST;
1978 }
1979
1980 int UtcDaliPropertyRegistrationAddSameIndex(void)
1981 {
1982   TestApplication application;
1983   int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 100;
1984
1985   // Add one property with a valid property index
1986   PropertyRegistration property1( customType1, "propName",  propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
1987
1988   // Attempt to add another property with the same index
1989   try
1990   {
1991     PropertyRegistration property2( customType1, "propName2",   propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
1992   }
1993   catch ( DaliException& e )
1994   {
1995     DALI_TEST_ASSERT( e, "! \"Property index already added", TEST_LOCATION );
1996   }
1997
1998   int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 100;
1999
2000   // Add one property with a valid property index
2001   AnimatablePropertyRegistration property3( customType1, "animPropName",   animatablePropertyIndex, Property::BOOLEAN );
2002
2003   // Attempt to add another property with the same index
2004   try
2005   {
2006     AnimatablePropertyRegistration property4( customType1, "animPropName2",    animatablePropertyIndex, Property::BOOLEAN );
2007   }
2008   catch ( DaliException& e )
2009   {
2010     DALI_TEST_ASSERT( e, "! \"Property index already added", TEST_LOCATION );
2011   }
2012   END_TEST;
2013 }
2014
2015 int UtcDaliPropertyRegistrationPropertyWritableP(void)
2016 {
2017   TestApplication application;
2018   int propertyIndex1 = PROPERTY_REGISTRATION_START_INDEX + 200;
2019   int propertyIndex2 = PROPERTY_REGISTRATION_START_INDEX + 201;
2020
2021   // Add two properties, one with SetProperty, one without
2022   PropertyRegistration property1( customType1, "propNameReadwrite",   propertyIndex1, Property::BOOLEAN, &SetProperty, &GetProperty );
2023   PropertyRegistration property2( customType1, "propNameReadonly",    propertyIndex2, Property::BOOLEAN, NULL, &GetProperty );
2024
2025   // Create custom-actor
2026   TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
2027   DALI_TEST_CHECK( typeInfo );
2028   BaseHandle handle = typeInfo.CreateInstance();
2029   DALI_TEST_CHECK( handle );
2030   Actor customActor = Actor::DownCast( handle );
2031   DALI_TEST_CHECK( customActor );
2032
2033   // Check whether properties are writable
2034   DALI_TEST_CHECK(   customActor.IsPropertyWritable( propertyIndex1 ) );
2035   DALI_TEST_CHECK( ! customActor.IsPropertyWritable( propertyIndex2 ) );
2036
2037
2038   // Check the property is writable in the type registry
2039   Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
2040
2041   DALI_TEST_EQUALS( typeInfoImpl.IsPropertyWritable( propertyIndex1 ), true, TEST_LOCATION );
2042
2043   END_TEST;
2044 }
2045
2046 int UtcDaliPropertyRegistrationPropertyWritableN(void)
2047 {
2048   // Currently Actors don't register properties with the type registry
2049
2050   TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
2051   Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
2052
2053   try
2054   {
2055     typeInfoImpl.IsPropertyWritable( Actor::Property::COLOR);
2056     tet_result( TET_FAIL );
2057
2058   }
2059   catch ( DaliException& e )
2060   {
2061      DALI_TEST_ASSERT( e, "Cannot find property index", TEST_LOCATION );
2062   }
2063   END_TEST;
2064
2065 }
2066 int UtcDaliPropertyRegistrationPropertyAnimatable(void)
2067 {
2068   TestApplication application;
2069   int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 400;
2070   int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 400;
2071
2072   // These properties are not animatable
2073   PropertyRegistration property1( customType1, "propName",  propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
2074
2075   // These properties are animatable
2076   AnimatablePropertyRegistration property2( customType1, "animPropName",   animatablePropertyIndex, Property::BOOLEAN );
2077
2078   // Create custom-actor
2079   TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
2080   DALI_TEST_CHECK( typeInfo );
2081   BaseHandle handle = typeInfo.CreateInstance();
2082   DALI_TEST_CHECK( handle );
2083   Actor customActor = Actor::DownCast( handle );
2084   DALI_TEST_CHECK( customActor );
2085
2086   // Check if animatable
2087   DALI_TEST_CHECK( ! customActor.IsPropertyAnimatable( propertyIndex ) );
2088   DALI_TEST_CHECK( customActor.IsPropertyAnimatable( animatablePropertyIndex ) );
2089
2090   // Create another instance of custom-actor
2091   BaseHandle handle2 = typeInfo.CreateInstance();
2092   DALI_TEST_CHECK( handle2 );
2093   Actor customActor2 = Actor::DownCast( handle2 );
2094   DALI_TEST_CHECK( customActor2 );
2095
2096   // Check if animatable
2097   DALI_TEST_CHECK( ! customActor2.IsPropertyAnimatable( propertyIndex ) );
2098   DALI_TEST_CHECK( customActor2.IsPropertyAnimatable( animatablePropertyIndex ) );
2099   END_TEST;
2100 }
2101
2102 int UtcDaliPropertyRegistrationInvalidGetAndSet(void)
2103 {
2104   TestApplication application;
2105   int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 2000;
2106   int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2000;
2107
2108   // Create custom-actor
2109   TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
2110   DALI_TEST_CHECK( typeInfo );
2111   BaseHandle handle = typeInfo.CreateInstance();
2112   DALI_TEST_CHECK( handle );
2113   Actor customActor = Actor::DownCast( handle );
2114   DALI_TEST_CHECK( customActor );
2115
2116   // Try to set an index that hasn't been added
2117   try
2118   {
2119     customActor.SetProperty( propertyIndex, true );
2120     tet_result( TET_FAIL );
2121   }
2122   catch ( DaliException& e )
2123   {
2124     DALI_TEST_ASSERT( e, "! \"Cannot find property index", TEST_LOCATION );
2125   }
2126
2127   try
2128   {
2129     customActor.SetProperty( animatablePropertyIndex, true );
2130     tet_result( TET_FAIL );
2131   }
2132   catch ( DaliException& e )
2133   {
2134     DALI_TEST_ASSERT( e, "! \"Cannot find property index", TEST_LOCATION );
2135   }
2136
2137   // Try to get an index that hasn't been added
2138   try
2139   {
2140     (void) customActor.GetProperty< bool >( propertyIndex );
2141     tet_result( TET_FAIL );
2142   }
2143   catch ( DaliException& e )
2144   {
2145     DALI_TEST_ASSERT( e, "! \"Cannot find property index", TEST_LOCATION );
2146   }
2147
2148   try
2149   {
2150     (void) customActor.GetProperty< bool >( animatablePropertyIndex );
2151     tet_result( TET_FAIL );
2152   }
2153   catch ( DaliException& e )
2154   {
2155     DALI_TEST_ASSERT( e, "! \"Cannot find property index", TEST_LOCATION );
2156   }
2157   END_TEST;
2158 }
2159
2160
2161 int UtcDaliLongPressGestureDetectorTypeRegistry(void)
2162 {
2163   TestApplication application;
2164
2165   Actor actor = Actor::New();
2166   actor.SetSize(100.0f, 100.0f);
2167   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
2168   Stage::GetCurrent().Add(actor);
2169
2170   // Register Type
2171   TypeInfo type;
2172   type = TypeRegistry::Get().GetTypeInfo( "LongPressGestureDetector" );
2173   DALI_TEST_CHECK( type );
2174   BaseHandle handle = type.CreateInstance();
2175   DALI_TEST_CHECK( handle );
2176   LongPressGestureDetector detector = LongPressGestureDetector::DownCast( handle );
2177   DALI_TEST_CHECK( detector );
2178
2179   // Attach actor to detector
2180   SignalData data;
2181   GestureReceivedFunctor functor( data );
2182   detector.Attach(actor);
2183
2184   // Connect to signal through type
2185   handle.ConnectSignal( &application, "longPressDetected",   functor );
2186
2187   // Render and notify
2188   application.SendNotification();
2189   application.Render();
2190
2191   // Emit gesture
2192   application.ProcessEvent(GenerateLongPress(Gesture::Possible, 1u, Vector2(50.0f, 10.0f)));
2193   application.ProcessEvent(GenerateLongPress(Gesture::Started, 1u, Vector2(50.0f, 10.0f)));
2194   application.ProcessEvent(GenerateLongPress(Gesture::Finished, 1u, Vector2(50.0f, 10.0f)));
2195   DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
2196   END_TEST;
2197 }
2198
2199 int UtcDaliPanGestureDetectorTypeRegistry(void)
2200 {
2201   TestApplication application;
2202
2203   Actor actor = Actor::New();
2204   actor.SetSize(100.0f, 100.0f);
2205   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
2206   Stage::GetCurrent().Add(actor);
2207
2208   // Register Type
2209   TypeInfo type;
2210   type = TypeRegistry::Get().GetTypeInfo( "PanGestureDetector" );
2211   DALI_TEST_CHECK( type );
2212   BaseHandle handle = type.CreateInstance();
2213   DALI_TEST_CHECK( handle );
2214   PanGestureDetector detector = PanGestureDetector::DownCast( handle );
2215   DALI_TEST_CHECK( detector );
2216
2217   // Attach actor to detector
2218   SignalData data;
2219   GestureReceivedFunctor functor( data );
2220   detector.Attach(actor);
2221
2222   // Connect to signal through type
2223   handle.ConnectSignal( &application, "panDetected",  functor );
2224
2225   // Render and notify
2226   application.SendNotification();
2227   application.Render();
2228
2229   // Emit gesture
2230   application.ProcessEvent(GeneratePan(Gesture::Possible, Vector2(10.0f, 20.0f), Vector2(20.0f, 20.0f), 10));
2231   application.ProcessEvent(GeneratePan(Gesture::Started, Vector2(10.0f, 20.0f), Vector2(20.0f, 20.0f), 10));
2232   application.ProcessEvent(GeneratePan(Gesture::Finished, Vector2(10.0f, 20.0f), Vector2(20.0f, 20.0f), 10));
2233   DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
2234   END_TEST;
2235 }
2236
2237 int UtcDaliPinchGestureDetectorTypeRegistry(void)
2238 {
2239   TestApplication application;
2240
2241   Actor actor = Actor::New();
2242   actor.SetSize(100.0f, 100.0f);
2243   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
2244   Stage::GetCurrent().Add(actor);
2245
2246   // Register Type
2247   TypeInfo type;
2248   type = TypeRegistry::Get().GetTypeInfo( "PinchGestureDetector" );
2249   DALI_TEST_CHECK( type );
2250   BaseHandle handle = type.CreateInstance();
2251   DALI_TEST_CHECK( handle );
2252   PinchGestureDetector detector = PinchGestureDetector::DownCast( handle );
2253   DALI_TEST_CHECK( detector );
2254
2255   // Attach actor to detector
2256   SignalData data;
2257   GestureReceivedFunctor functor( data );
2258   detector.Attach(actor);
2259
2260   // Connect to signal through type
2261   handle.ConnectSignal( &application, "pinchDetected",  functor );
2262
2263   // Render and notify
2264   application.SendNotification();
2265   application.Render();
2266
2267   // Emit gesture
2268   application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
2269   DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
2270   END_TEST;
2271 }
2272
2273 int UtcDaliTapGestureDetectorTypeRegistry(void)
2274 {
2275   TestApplication application;
2276
2277   Actor actor = Actor::New();
2278   actor.SetSize(100.0f, 100.0f);
2279   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
2280   Stage::GetCurrent().Add(actor);
2281
2282   // Register Type
2283   TypeInfo type;
2284   type = TypeRegistry::Get().GetTypeInfo( "TapGestureDetector" );
2285   DALI_TEST_CHECK( type );
2286   BaseHandle handle = type.CreateInstance();
2287   DALI_TEST_CHECK( handle );
2288   TapGestureDetector detector = TapGestureDetector::DownCast( handle );
2289   DALI_TEST_CHECK( detector );
2290
2291   // Attach actor to detector
2292   SignalData data;
2293   GestureReceivedFunctor functor( data );
2294   detector.Attach(actor);
2295
2296   // Connect to signal through type
2297   handle.ConnectSignal( &application, "tapDetected",  functor );
2298
2299   // Render and notify
2300   application.SendNotification();
2301   application.Render();
2302
2303   // Emit gesture
2304   application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
2305   application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
2306   DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
2307   END_TEST;
2308 }
2309
2310 int UtcDaliTypeRegistryNamedType(void)
2311 {
2312   TestApplication application;
2313   TypeRegistry typeRegistry = TypeRegistry::Get();
2314
2315   // Create a normal actor
2316   BaseHandle actorHandle = typeRegistry.GetTypeInfo( "Actor" ).CreateInstance();
2317   DALI_TEST_CHECK( actorHandle );
2318   Actor actor( Actor::DownCast( actorHandle ) );
2319   DALI_TEST_CHECK( actor );
2320   unsigned int actorPropertyCount( actor.GetPropertyCount() );
2321
2322   // Create Named Actor Type
2323   BaseHandle namedHandle = typeRegistry.GetTypeInfo( "MyNamedActor" ).CreateInstance();
2324   DALI_TEST_CHECK( namedHandle );
2325   Actor namedActor( Actor::DownCast( namedHandle ) );
2326   DALI_TEST_CHECK( namedActor );
2327   unsigned int namedActorPropertyCount( namedActor.GetPropertyCount() );
2328
2329   DALI_TEST_CHECK( namedActorPropertyCount > actorPropertyCount );
2330   END_TEST;
2331 }
2332
2333 int UtcDaliTypeInfoGetActionNameP(void)
2334 {
2335   TestApplication application;
2336   TypeRegistry typeRegistry = TypeRegistry::Get();
2337
2338   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2339   DALI_TEST_CHECK( typeInfo );
2340
2341   DALI_TEST_CHECK( 0 != typeInfo.GetActionCount() );
2342
2343   std::string name = typeInfo.GetActionName(0);
2344
2345   DALI_TEST_EQUALS( name, "show", TEST_LOCATION );
2346
2347
2348   TypeInfo typeInfo2 = typeRegistry.GetTypeInfo( "MyTestCustomActor" );
2349
2350   //  search for show action in base class, given a derived class
2351   bool foundChildAction = false;
2352   for( std::size_t i = 0; i < typeInfo2.GetActionCount(); i++ )
2353   {
2354
2355        std::string name = typeInfo2.GetActionName( i );
2356        if( name == "show")
2357        {
2358          foundChildAction = true;
2359        }
2360
2361   }
2362
2363   DALI_TEST_EQUALS( foundChildAction, true, TEST_LOCATION );
2364
2365
2366   END_TEST;
2367 }
2368
2369 int UtcDaliTypeInfoGetActionNameN(void)
2370 {
2371   TestApplication application;
2372   TypeRegistry typeRegistry = TypeRegistry::Get();
2373
2374   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2375   DALI_TEST_CHECK( typeInfo );
2376
2377   DALI_TEST_CHECK( 0 != typeInfo.GetActionCount() );
2378
2379   std::string name = typeInfo.GetActionName(std::numeric_limits<size_t>::max());
2380
2381   DALI_TEST_EQUALS( 0u, name.size(), TEST_LOCATION );
2382
2383   END_TEST;
2384 }
2385
2386 int UtcDaliTypeInfoGetSignalNameP(void)
2387 {
2388   TestApplication application;
2389   TypeRegistry typeRegistry = TypeRegistry::Get();
2390
2391   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2392   DALI_TEST_CHECK( typeInfo );
2393
2394   DALI_TEST_CHECK( 0 != typeInfo.GetSignalCount() );
2395
2396   std::string name = typeInfo.GetSignalName(0);
2397
2398   DALI_TEST_EQUALS( name, "touched", TEST_LOCATION );
2399
2400   TypeInfo typeInfo2 = typeRegistry.GetTypeInfo( "MyTestCustomActor" );
2401
2402   //  search for signal in base class, given a derived class
2403   bool foundSignal = false;
2404   for( std::size_t i = 0; i < typeInfo2.GetSignalCount(); i++ )
2405   {
2406
2407        std::string name = typeInfo2.GetSignalName( i );
2408        if( name == "touched")
2409        {
2410          foundSignal = true;
2411        }
2412
2413   }
2414
2415   DALI_TEST_EQUALS( foundSignal, true, TEST_LOCATION );
2416
2417   END_TEST;
2418 }
2419
2420 int UtcDaliTypeInfoGetSignalNameN(void)
2421 {
2422   TestApplication application;
2423   TypeRegistry typeRegistry = TypeRegistry::Get();
2424
2425   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2426   DALI_TEST_CHECK( typeInfo );
2427
2428   DALI_TEST_CHECK( 0 != typeInfo.GetSignalCount() );
2429
2430   std::string name = typeInfo.GetSignalName(std::numeric_limits<size_t>::max());
2431
2432   DALI_TEST_EQUALS( 0u, name.size(), TEST_LOCATION );
2433
2434   END_TEST;
2435 }
2436
2437
2438 int UtcDaliTypeInfoGetCreatorP(void)
2439 {
2440   TestApplication application;
2441   TypeRegistry typeRegistry = TypeRegistry::Get();
2442
2443   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2444   DALI_TEST_CHECK( typeInfo );
2445
2446   TypeInfo::CreateFunction createFn = typeInfo.GetCreator();
2447   DALI_TEST_EQUALS( createFn != NULL, true, TEST_LOCATION );
2448   if( createFn )
2449   {
2450     // try calling it:
2451     BaseHandle handle = createFn();
2452     DALI_TEST_EQUALS( (bool)handle, true, TEST_LOCATION );
2453   }
2454
2455   END_TEST;
2456 }
2457
2458 int UtcDaliTypeInfoGetCreatorN(void)
2459 {
2460   TestApplication application;
2461   TypeRegistry typeRegistry = TypeRegistry::Get();
2462
2463   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "MyTestCustomActor3" );
2464   DALI_TEST_CHECK( typeInfo );
2465
2466   TypeInfo::CreateFunction createFn = typeInfo.GetCreator();
2467   DALI_TEST_EQUALS( createFn == NULL, true, TEST_LOCATION );
2468
2469   END_TEST;
2470 }
2471
2472 int UtcDaliTypeInfoGetPropertyCountP1(void)
2473 {
2474   TestApplication application;
2475   TypeRegistry typeRegistry = TypeRegistry::Get();
2476
2477   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2478   DALI_TEST_CHECK( typeInfo );
2479   size_t actorPropertyCount = typeInfo.GetPropertyCount();
2480
2481   DALI_TEST_EQUALS( actorPropertyCount == 0 , true, TEST_LOCATION ); // No event only props
2482   END_TEST;
2483 }
2484
2485 int UtcDaliTypeInfoGetPropertyCountP2(void)
2486 {
2487   TestApplication application;
2488   TypeRegistry typeRegistry = TypeRegistry::Get();
2489
2490   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "MyTestCustomActor2" );
2491   DALI_TEST_CHECK( typeInfo );
2492   size_t propertyCount = typeInfo.GetPropertyCount();
2493   Property::IndexContainer indices;
2494   typeInfo.GetPropertyIndices( indices );
2495
2496   DALI_TEST_EQUALS( propertyCount > 0 && propertyCount <= indices.Size(), true, TEST_LOCATION );
2497   DALI_TEST_EQUALS( propertyCount == 2, true, TEST_LOCATION );
2498
2499   END_TEST;
2500 }
2501
2502 int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGet01(void)
2503 {
2504   TestApplication application;
2505   TypeRegistry typeRegistry = TypeRegistry::Get();
2506
2507   tet_infoline( "Register a type registered animatable property and ensure set/get behaviour works synchronously" );
2508
2509   // Register animatable property
2510   const int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
2511   AnimatablePropertyRegistration animatableProperty( customType1, "animatableProp1", animatablePropertyIndex, Property::FLOAT );
2512
2513   // Check property count before property registration
2514   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
2515   DALI_TEST_CHECK( typeInfo );
2516   BaseHandle handle = typeInfo.CreateInstance();
2517   DALI_TEST_CHECK( handle );
2518   Actor customActor = Actor::DownCast( handle );
2519   DALI_TEST_CHECK( customActor );
2520   Stage::GetCurrent().Add(customActor);
2521
2522   tet_infoline( "Set the value and ensure it changes straight away" );
2523   DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 0.0f, TEST_LOCATION );
2524   customActor.SetProperty( animatablePropertyIndex, 25.0f );
2525   DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 25.0f, TEST_LOCATION );
2526
2527   tet_infoline( "Check latest scene-graph value is unchanged" );
2528   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 0.0f, TEST_LOCATION );
2529
2530   // Render and notify
2531   application.SendNotification();
2532   application.Render();
2533
2534   tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
2535
2536   DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 25.0f, TEST_LOCATION );
2537   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 25.0f, TEST_LOCATION );
2538
2539   END_TEST;
2540 }
2541
2542 int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGetWithComponentsVector2(void)
2543 {
2544   TestApplication application;
2545   TypeRegistry typeRegistry = TypeRegistry::Get();
2546
2547   tet_infoline( "Register a type registered animatable property that has component indices and ensure set/get behaviour works synchronously and is the same regardless of how the property is set" );
2548
2549   // Register the animatable propeties
2550   const int basePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
2551   const int componentZeroPropertyIndex( basePropertyIndex + 1 );
2552   const int componentOnePropertyIndex( componentZeroPropertyIndex + 1 );
2553   AnimatablePropertyRegistration baseAnimatableProperty( customType1, "baseProp", basePropertyIndex, Vector2( 13.0f, 24.0f ) );
2554   AnimatablePropertyComponentRegistration componentZeroAnimatableProperty( customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0 );
2555   AnimatablePropertyComponentRegistration componentOneAnimatableProperty( customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1 );
2556
2557   // Check property count before property registration
2558   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
2559   DALI_TEST_CHECK( typeInfo );
2560   BaseHandle handle = typeInfo.CreateInstance();
2561   DALI_TEST_CHECK( handle );
2562   Actor customActor = Actor::DownCast( handle );
2563   DALI_TEST_CHECK( customActor );
2564   Stage::GetCurrent().Add(customActor);
2565
2566   tet_infoline( "Get the component values, they should be the default value of the base-property" );
2567   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2568   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2569   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 13.0f, 24.0f ), TEST_LOCATION );
2570
2571   tet_infoline( "Set a component value and ensure it changes for the base property as well" );
2572   customActor.SetProperty( componentZeroPropertyIndex, 125.0f );
2573   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2574   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 24.0f ), TEST_LOCATION );
2575
2576   customActor.SetProperty( componentOnePropertyIndex, 225.0f );
2577   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2578   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 225.0f ), TEST_LOCATION );
2579
2580   tet_infoline( "Check latest scene-graph value is unchanged" );
2581   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( basePropertyIndex ), Vector2( 13.0f, 24.0f ), TEST_LOCATION );
2582   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2583   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2584
2585   // Render and notify
2586   application.SendNotification();
2587   application.Render();
2588
2589   tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
2590   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 225.0f ), TEST_LOCATION );
2591   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2592   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2593
2594   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 225.0f ), TEST_LOCATION );
2595   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2596   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2597
2598   tet_infoline( "Set the base property value and ensure the component values reflect the change" );
2599   customActor.SetProperty( basePropertyIndex, Vector2( 1.0f, 2.0f ) );
2600   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 1.0f, TEST_LOCATION );
2601   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 2.0f, TEST_LOCATION );
2602   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 1.0f, 2.0f ), TEST_LOCATION );
2603
2604   END_TEST;
2605 }
2606
2607 int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGetWithComponentsVector3(void)
2608 {
2609   TestApplication application;
2610   TypeRegistry typeRegistry = TypeRegistry::Get();
2611
2612   tet_infoline( "Register a type registered animatable property that has component indices and ensure set/get behaviour works synchronously and is the same regardless of how the property is set" );
2613
2614   // Register the animatable propeties
2615   const int basePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
2616   const int componentZeroPropertyIndex( basePropertyIndex + 1 );
2617   const int componentOnePropertyIndex( componentZeroPropertyIndex + 1 );
2618   const int componentTwoPropertyIndex( componentOnePropertyIndex + 1 );
2619   AnimatablePropertyRegistration baseAnimatableProperty( customType1, "baseProp", basePropertyIndex, Vector3( 13.0f, 24.0f, 35.0 ) );
2620   AnimatablePropertyComponentRegistration componentZeroAnimatableProperty( customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0 );
2621   AnimatablePropertyComponentRegistration componentOneAnimatableProperty( customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1 );
2622   AnimatablePropertyComponentRegistration componentTwoAnimatableProperty( customType1, "componentTwoProp", componentTwoPropertyIndex, basePropertyIndex, 2 );
2623
2624   // Check property count before property registration
2625   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
2626   DALI_TEST_CHECK( typeInfo );
2627   BaseHandle handle = typeInfo.CreateInstance();
2628   DALI_TEST_CHECK( handle );
2629   Actor customActor = Actor::DownCast( handle );
2630   DALI_TEST_CHECK( customActor );
2631   Stage::GetCurrent().Add(customActor);
2632
2633   tet_infoline( "Get the component values, they should be the default value of the base-property" );
2634   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2635   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2636   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
2637   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 13.0f, 24.0f, 35.0f ), TEST_LOCATION );
2638
2639   tet_infoline( "Set a component value and ensure it changes for the base property as well" );
2640   customActor.SetProperty( componentZeroPropertyIndex, 125.0f );
2641   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2642   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 24.0f, 35.0f ), TEST_LOCATION );
2643
2644   customActor.SetProperty( componentOnePropertyIndex, 225.0f );
2645   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2646   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 35.0f ), TEST_LOCATION );
2647
2648   customActor.SetProperty( componentTwoPropertyIndex, 325.0f );
2649   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2650   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 325.0f ), TEST_LOCATION );
2651
2652   tet_infoline( "Check latest scene-graph value is unchanged" );
2653   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector3 >( basePropertyIndex ), Vector3( 13.0f, 24.0f, 35.0f ), TEST_LOCATION );
2654   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2655   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2656   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
2657
2658   // Render and notify
2659   application.SendNotification();
2660   application.Render();
2661
2662   tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
2663   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 325.0f ), TEST_LOCATION );
2664   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2665   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2666   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2667
2668   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 325.0f ), TEST_LOCATION );
2669   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2670   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2671   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2672
2673   tet_infoline( "Set the base property value and ensure the component values reflect the change" );
2674   customActor.SetProperty( basePropertyIndex, Vector3( 1.0f, 2.0f, 3.0f ) );
2675   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 1.0f, TEST_LOCATION );
2676   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 2.0f, TEST_LOCATION );
2677   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 3.0f, TEST_LOCATION );
2678   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 1.0f, 2.0f, 3.0f ), TEST_LOCATION );
2679
2680   END_TEST;
2681 }
2682
2683 int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGetWithComponentsVector4(void)
2684 {
2685   TestApplication application;
2686   TypeRegistry typeRegistry = TypeRegistry::Get();
2687
2688   tet_infoline( "Register a type registered animatable property that has component indices and ensure set/get behaviour works synchronously and is the same regardless of how the property is set" );
2689
2690   // Register the animatable propeties
2691   const int basePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
2692   const int componentZeroPropertyIndex( basePropertyIndex + 1 );
2693   const int componentOnePropertyIndex( componentZeroPropertyIndex + 1 );
2694   const int componentTwoPropertyIndex( componentOnePropertyIndex + 1 );
2695   const int componentThreePropertyIndex( componentTwoPropertyIndex + 1 );
2696   AnimatablePropertyRegistration baseAnimatableProperty( customType1, "baseProp", basePropertyIndex, Vector4( 13.0f, 24.0f, 35.0, 47.0f ) );
2697   AnimatablePropertyComponentRegistration componentZeroAnimatableProperty( customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0 );
2698   AnimatablePropertyComponentRegistration componentOneAnimatableProperty( customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1 );
2699   AnimatablePropertyComponentRegistration componentTwoAnimatableProperty( customType1, "componentTwoProp", componentTwoPropertyIndex, basePropertyIndex, 2 );
2700   AnimatablePropertyComponentRegistration componentThreeAnimatableProperty( customType1, "componentThreeProp", componentThreePropertyIndex, basePropertyIndex, 3 );
2701
2702   // Check property count before property registration
2703   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
2704   DALI_TEST_CHECK( typeInfo );
2705   BaseHandle handle = typeInfo.CreateInstance();
2706   DALI_TEST_CHECK( handle );
2707   Actor customActor = Actor::DownCast( handle );
2708   DALI_TEST_CHECK( customActor );
2709   Stage::GetCurrent().Add(customActor);
2710
2711   tet_infoline( "Get the component values, they should be the default value of the base-property" );
2712   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2713   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2714   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
2715   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 47.0f, TEST_LOCATION );
2716   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 13.0f, 24.0f, 35.0f, 47.0f ), TEST_LOCATION );
2717
2718   tet_infoline( "Set a component value and ensure it changes for the base property as well" );
2719   customActor.SetProperty( componentZeroPropertyIndex, 125.0f );
2720   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2721   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 24.0f, 35.0f, 47.0f ), TEST_LOCATION );
2722
2723   customActor.SetProperty( componentOnePropertyIndex, 225.0f );
2724   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2725   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 35.0f, 47.0f ), TEST_LOCATION );
2726
2727   customActor.SetProperty( componentTwoPropertyIndex, 325.0f );
2728   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2729   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 47.0f ), TEST_LOCATION );
2730
2731   customActor.SetProperty( componentThreePropertyIndex, 435.0f );
2732   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 435.0f, TEST_LOCATION );
2733   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 435.0f ), TEST_LOCATION );
2734
2735   tet_infoline( "Check latest scene-graph value is unchanged" );
2736   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector4 >( basePropertyIndex ), Vector4( 13.0f, 24.0f, 35.0f, 47.0f ), TEST_LOCATION );
2737   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2738   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2739   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
2740   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentThreePropertyIndex ), 47.0f, TEST_LOCATION );
2741
2742   // Render and notify
2743   application.SendNotification();
2744   application.Render();
2745
2746   tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
2747   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 435.0f ), TEST_LOCATION );
2748   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2749   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2750   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2751   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 435.0f, TEST_LOCATION );
2752
2753   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 435.0f ), TEST_LOCATION );
2754   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2755   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2756   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2757   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentThreePropertyIndex ), 435.0f, TEST_LOCATION );
2758
2759   tet_infoline( "Set the base property value and ensure the component values reflect the change" );
2760   customActor.SetProperty( basePropertyIndex, Vector4( 1.0f, 2.0f, 3.0f, 4.0f ) );
2761   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 1.0f, TEST_LOCATION );
2762   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 2.0f, TEST_LOCATION );
2763   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 3.0f, TEST_LOCATION );
2764   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 4.0f, TEST_LOCATION );
2765   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 1.0f, 2.0f, 3.0f, 4.0f ), TEST_LOCATION );
2766
2767   END_TEST;
2768 }