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 UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationN(void)
1436 {
1437   TestApplication application;
1438   TypeRegistry typeRegistry = TypeRegistry::Get();
1439
1440   // Register animatable property with the type of Vector2
1441   int animatablePropertyIndex1( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
1442   AnimatablePropertyRegistration animatableProperty1( customType1, "animatableProp1",   animatablePropertyIndex1, Property::VECTOR2 );
1443
1444   // Attempt to register an animatable property component out-of-bounds index (less than)
1445   try
1446   {
1447     AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X",    ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, animatablePropertyIndex1, 0 );
1448     tet_result( TET_FAIL );
1449   }
1450   catch ( DaliException& e )
1451   {
1452     DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1453   }
1454
1455   // Attempt to register an animatable property component out-of-bounds index (greater than)
1456   try
1457   {
1458     AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X",    ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, animatablePropertyIndex1, 0 );
1459     tet_result( TET_FAIL );
1460   }
1461   catch ( DaliException& e )
1462   {
1463     DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1464   }
1465
1466   // Register an animatable property component
1467   AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X",    ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1, animatablePropertyIndex1, 0 );
1468
1469   // Attempt to register another animatable property component with the same component index
1470   try
1471   {
1472     AnimatablePropertyComponentRegistration propertyComponent2( customType1, "animatableProp1Y",    ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2, animatablePropertyIndex1, 0 );
1473     tet_result( TET_FAIL );
1474   }
1475   catch ( DaliException& e )
1476   {
1477     DALI_TEST_ASSERT( e, "Property component already registered", TEST_LOCATION );
1478   }
1479
1480   // Register animatable property with the type of boolean
1481   int animatablePropertyIndex2( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2 );
1482   AnimatablePropertyRegistration animatableProperty2( customType1, "animatableProp2",   animatablePropertyIndex2, Property::BOOLEAN );
1483
1484   // Attempt to register an animatable property component for the above property with boolean type
1485   try
1486   {
1487     AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp2X",    animatablePropertyIndex2 + 1, animatablePropertyIndex2, 0 );
1488     tet_result( TET_FAIL );
1489   }
1490   catch ( DaliException& e )
1491   {
1492     DALI_TEST_ASSERT( e, "Base property does not support component", TEST_LOCATION );
1493   }
1494
1495   END_TEST;
1496 }
1497
1498 int UtcDaliTypeRegistryChildPropertyRegistrationP(void)
1499 {
1500   TestApplication application;
1501   TypeRegistry typeRegistry = TypeRegistry::Get();
1502
1503   // Check property count before property registration
1504   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
1505   DALI_TEST_CHECK( typeInfo );
1506   BaseHandle handle = typeInfo.CreateInstance();
1507   DALI_TEST_CHECK( handle );
1508   Actor customActor = Actor::DownCast( handle );
1509   DALI_TEST_CHECK( customActor );
1510   unsigned int initialPropertyCount( customActor.GetPropertyCount() );
1511
1512   // Register child properties to the parent
1513   std::string propertyName( "childProp1" );
1514   int propertyIndex( CHILD_PROPERTY_REGISTRATION_START_INDEX );
1515   Property::Type propertyType( Property::BOOLEAN );
1516   ChildPropertyRegistration childProperty1( customType1, propertyName, propertyIndex, propertyType );
1517
1518   std::string propertyName2( "childProp2" );
1519   int propertyIndex2( CHILD_PROPERTY_REGISTRATION_START_INDEX + 1 );
1520   Property::Type propertyType2( Property::INTEGER );
1521   ChildPropertyRegistration childProperty2( customType1, propertyName2, propertyIndex2, propertyType2 );
1522
1523   std::string propertyName3( "childProp3" );
1524   int propertyIndex3( CHILD_PROPERTY_REGISTRATION_START_INDEX + 2 );
1525   Property::Type propertyType3( Property::FLOAT );
1526   ChildPropertyRegistration childProperty3( customType1, propertyName3, propertyIndex3, propertyType3 );
1527
1528   std::string propertyName4( "childProp4" );
1529   int propertyIndex4( CHILD_PROPERTY_REGISTRATION_START_INDEX + 3 );
1530   Property::Type propertyType4( Property::INTEGER );
1531   ChildPropertyRegistration childProperty4( customType1, propertyName4, propertyIndex4, propertyType4 );
1532
1533   // Check property count are not changed because the child properties will not be created for the parent
1534   DALI_TEST_EQUALS( initialPropertyCount, customActor.GetPropertyCount(), TEST_LOCATION );
1535
1536   // check the child property type
1537   Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
1538   Property::Type type = typeInfoImpl.GetChildPropertyType( typeInfoImpl.GetChildPropertyIndex("childProp4") );
1539   DALI_TEST_EQUALS( type, Property::INTEGER, TEST_LOCATION );
1540
1541
1542   // Create a child actor
1543   Actor childActor = Actor::New();
1544   DALI_TEST_CHECK( childActor );
1545   unsigned int initialChildActorPropertyCount( childActor.GetPropertyCount() );
1546
1547   // The type of child properties should be Property::None as the child hasn't registered any child property yet.
1548   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex ), Property::NONE, TEST_LOCATION );
1549   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex2 ), Property::NONE, TEST_LOCATION );
1550   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex3 ), Property::NONE, TEST_LOCATION );
1551   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex4 ), Property::NONE, TEST_LOCATION );
1552
1553   // Set the value for the first child property when the child actor doesn't have a parent yet
1554   childActor.SetProperty(propertyIndex, true);
1555
1556   // Check that the first child property is dynamically created
1557   DALI_TEST_EQUALS( initialChildActorPropertyCount + 1u, childActor.GetPropertyCount(), TEST_LOCATION );
1558
1559   // Check the first child property value
1560   DALI_TEST_EQUALS( childActor.GetProperty< bool >( propertyIndex ), true, TEST_LOCATION );
1561
1562   // Check the first child property type
1563   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex ), propertyType, TEST_LOCATION );
1564
1565   // Check that the first child property have no name, as it doesn't have a parent yet.
1566   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex ), "", TEST_LOCATION );
1567
1568   // Check that the first property can't be accessed through its name, as it doesn't have a parent yet.
1569   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName ), Property::INVALID_INDEX, TEST_LOCATION );
1570
1571   // Create a custom property for the child with the same name as the second child property registered to the parent
1572   Property::Index customPropertyIndex = childActor.RegisterProperty(propertyName2, 100, Property::READ_WRITE);
1573
1574   // Check that the custom property is created
1575   DALI_TEST_EQUALS( initialChildActorPropertyCount + 2u, childActor.GetPropertyCount(), TEST_LOCATION );
1576
1577   // Check the property value
1578   DALI_TEST_EQUALS( childActor.GetProperty< int >( customPropertyIndex ), 100, TEST_LOCATION );
1579
1580   // Check the property index
1581   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName2 ), customPropertyIndex, TEST_LOCATION );
1582
1583   // Check the property type
1584   DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex ), propertyType2, TEST_LOCATION );
1585
1586   // Check the property name
1587   DALI_TEST_EQUALS( childActor.GetPropertyName( customPropertyIndex ), propertyName2, TEST_LOCATION );
1588
1589   // Now add the child actor to the parent
1590   customActor.Add( childActor );
1591
1592   // Check that the first child property now has the correct name as previously registered to the parent
1593   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex ), propertyName, TEST_LOCATION );
1594
1595   // Check that the child property index for the first child property can now be retrieved through its child property name
1596   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName ), propertyIndex, TEST_LOCATION );
1597
1598   // Check that the second child property now has the correct index as previously registered to the parent
1599   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex2 ), propertyName2, TEST_LOCATION );
1600
1601   // Check that the second child property can be accessed through both its custom property index and its child property index
1602   DALI_TEST_EQUALS( childActor.GetProperty< int >( customPropertyIndex ), 100, TEST_LOCATION );
1603   DALI_TEST_EQUALS( childActor.GetProperty< int >( propertyIndex2 ), 100, TEST_LOCATION );
1604   DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex ), propertyType2, TEST_LOCATION );
1605   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex2 ), propertyType2, TEST_LOCATION );
1606
1607   // Check that the child property index for the second child property can now be retrieved through its child property name
1608   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName2 ), propertyIndex2, TEST_LOCATION );
1609
1610   // Set the value for the third child property when the child actor is already added to the parent
1611   childActor.SetProperty(propertyIndex3, 0.15f);
1612
1613   // Check that the third child property is dynamically created
1614   DALI_TEST_EQUALS( initialChildActorPropertyCount + 3u, childActor.GetPropertyCount(), TEST_LOCATION );
1615
1616   // Check the third child property value
1617   DALI_TEST_EQUALS( childActor.GetProperty< float >( propertyIndex3 ), 0.15f, TEST_LOCATION );
1618
1619   // Check the third child property type
1620   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex3 ), propertyType3, TEST_LOCATION );
1621
1622   // Check the third child property name
1623   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex3 ), propertyName3, TEST_LOCATION );
1624
1625   // Check the third child property index.
1626   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName3 ), propertyIndex3, TEST_LOCATION );
1627
1628   // Create a custom property for the child with the same name as the fourth child property registered to the parent
1629   Property::Index customPropertyIndex2 = childActor.RegisterProperty(propertyName4, 20, Property::READ_WRITE);
1630
1631   // Check that the custom property is created
1632   DALI_TEST_EQUALS( initialChildActorPropertyCount + 4u, childActor.GetPropertyCount(), TEST_LOCATION );
1633
1634   // Check the fourth child property value
1635   DALI_TEST_EQUALS( childActor.GetProperty< int >( propertyIndex4 ), 20, TEST_LOCATION );
1636   DALI_TEST_EQUALS( childActor.GetProperty< int >( customPropertyIndex2 ), 20, TEST_LOCATION );
1637
1638   // Check the fourth child property type
1639   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex4 ), propertyType4, TEST_LOCATION );
1640   DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex2 ), propertyType4, TEST_LOCATION );
1641
1642   // Check the fourth child property name
1643   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex4 ), propertyName4, TEST_LOCATION );
1644   DALI_TEST_EQUALS( childActor.GetPropertyName( customPropertyIndex2 ), propertyName4, TEST_LOCATION );
1645
1646   // Check the fourth child property index.
1647   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName4 ), propertyIndex4, TEST_LOCATION );
1648
1649   // Now create another parent actor with different child properties registered
1650   TypeInfo typeInfo2 = typeRegistry.GetTypeInfo( "MyNamedActor" );
1651   DALI_TEST_CHECK( typeInfo2 );
1652   BaseHandle handle2 = typeInfo2.CreateInstance();
1653   DALI_TEST_CHECK( handle2 );
1654   Actor customActor2 = Actor::DownCast( handle2 );
1655   DALI_TEST_CHECK( customActor2 );
1656
1657   // Register child properties to the new parent
1658   std::string newPropertyName( "newChildProp" );
1659   int newPropertyIndex( CHILD_PROPERTY_REGISTRATION_START_INDEX ); // The same index as the first child property "childProp1" in the old parent
1660   Property::Type newPropertyType( Property::VECTOR2 );
1661   ChildPropertyRegistration newChildProperty( namedActorType, newPropertyName, newPropertyIndex, newPropertyType );
1662
1663   std::string newPropertyName2( "childProp3" ); // The same name as the third child property in the old parent
1664   int newPropertyIndex2( CHILD_PROPERTY_REGISTRATION_START_INDEX + 1 ); // The same index as the second child property "childProp2" in the old parent
1665   Property::Type newPropertyType2( Property::FLOAT ); // The same type as the third child property in the old parent
1666   ChildPropertyRegistration newChildProperty2( namedActorType, newPropertyName2, newPropertyIndex2, newPropertyType2 );
1667
1668   // Now move the child actor to the new parent
1669   customActor2.Add( childActor );
1670
1671   // "childProp1" is not a valid child property supported by the new parent, so nothing changed
1672   DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex ), propertyType, TEST_LOCATION );
1673   DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex ), propertyName, TEST_LOCATION );
1674   DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName ), propertyIndex, TEST_LOCATION );
1675
1676   // "childProp3" is a valid child property supported by the new parent
1677   // So it should get its new child property index and should just work
1678   DALI_TEST_EQUALS( childActor.GetPropertyType( newPropertyIndex2 ), newPropertyType2, TEST_LOCATION );
1679   DALI_TEST_EQUALS( childActor.GetPropertyName( newPropertyIndex2 ), newPropertyName2, TEST_LOCATION );
1680   DALI_TEST_EQUALS( childActor.GetPropertyIndex( newPropertyName2 ), newPropertyIndex2, TEST_LOCATION );
1681   DALI_TEST_EQUALS( childActor.GetProperty< float >( newPropertyIndex2 ), 0.15f, TEST_LOCATION );
1682
1683   // Now register a custom property called "newChildProp"
1684   Property::Index customPropertyIndex3 = childActor.RegisterProperty("newChildProp", Vector2( 10.0f, 10.0f ), Property::READ_WRITE);
1685
1686   // Check that the custom property is created
1687   DALI_TEST_EQUALS( initialChildActorPropertyCount + 5u, childActor.GetPropertyCount(), TEST_LOCATION );
1688
1689   // This is a valid child property registered to the new parent
1690   // So should be able to access it through both its custom property index and its registered child property index
1691   DALI_TEST_EQUALS( childActor.GetPropertyType( newPropertyIndex ), newPropertyType, TEST_LOCATION );
1692   DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex3 ), newPropertyType, TEST_LOCATION );
1693   DALI_TEST_EQUALS( childActor.GetPropertyName( newPropertyIndex ), newPropertyName, TEST_LOCATION ); // This should return the new name, although the child property index remains the same
1694   DALI_TEST_EQUALS( childActor.GetPropertyName( customPropertyIndex3 ), newPropertyName, TEST_LOCATION );
1695   DALI_TEST_EQUALS( childActor.GetProperty< Vector2 >( newPropertyIndex ), Vector2( 10.0f, 10.0f ), TEST_LOCATION );
1696   DALI_TEST_EQUALS( childActor.GetProperty< Vector2 >( customPropertyIndex3 ), Vector2( 10.0f, 10.0f ), TEST_LOCATION );
1697
1698   // Should return the child property index by given its name
1699   DALI_TEST_EQUALS( childActor.GetPropertyIndex( newPropertyName ), newPropertyIndex, TEST_LOCATION );
1700
1701
1702   END_TEST;
1703 }
1704
1705 int UtcDaliTypeRegistryChildPropertyRegistrationN(void)
1706 {
1707   TestApplication application;
1708   TypeRegistry typeRegistry = TypeRegistry::Get();
1709
1710   // Attempt to register a child property type out-of-bounds index (less than)
1711   try
1712   {
1713     ChildPropertyRegistration property1( customType1, "propName",  CHILD_PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN );
1714     tet_result( TET_FAIL );
1715   }
1716   catch ( DaliException& e )
1717   {
1718     DALI_TEST_ASSERT( e, "( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1719   }
1720
1721   // Attempt to register a child property type out-of-bounds index (greater than)
1722   try
1723   {
1724     ChildPropertyRegistration property1( customType1, "propName",  CHILD_PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN );
1725     tet_result( TET_FAIL );
1726   }
1727   catch ( DaliException& e )
1728   {
1729     DALI_TEST_ASSERT( e, "( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
1730   }
1731
1732   END_TEST;
1733 }
1734
1735
1736 /*******************************************************************************
1737  *
1738  * Action through the base handle
1739  *
1740  ******************************************************************************/
1741 int UtcDaliTypeRegistryActionViaBaseHandle(void)
1742 {
1743   TestApplication application;
1744
1745   TypeInfo type;
1746
1747   type = TypeRegistry::Get().GetTypeInfo( "Actor" );
1748   DALI_TEST_CHECK( type );
1749
1750   BaseHandle hdl = type.CreateInstance();
1751   DALI_TEST_CHECK( hdl );
1752
1753   Actor a = Actor::DownCast(hdl);
1754   DALI_TEST_CHECK( a );
1755
1756   a.SetVisible(false);
1757
1758   application.SendNotification();
1759   application.Render(0);
1760   DALI_TEST_CHECK(!a.IsVisible());
1761
1762   Property::Map attributes;
1763
1764   DALI_TEST_CHECK(hdl.DoAction("show", attributes));
1765
1766   application.SendNotification();
1767   application.Render(0);
1768   DALI_TEST_CHECK(a.IsVisible());
1769
1770   DALI_TEST_CHECK(!hdl.DoAction("unknownAction",  attributes));
1771   END_TEST;
1772 }
1773
1774 int UtcDaliPropertyRegistrationFunctions(void)
1775 {
1776   TestApplication application;
1777   int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 10;
1778
1779   // Attempt to register a property without a setter
1780   try
1781   {
1782     PropertyRegistration property1( customType1, "propName",  propertyIndex++, Property::BOOLEAN, NULL, &GetProperty );
1783     tet_result( TET_PASS );
1784   }
1785   catch ( DaliException& e )
1786   {
1787     tet_result( TET_FAIL );
1788   }
1789
1790   // Attempt to register a property without a getter
1791   try
1792   {
1793     PropertyRegistration property1( customType1, "propName",  propertyIndex++, Property::BOOLEAN, NULL, NULL );
1794     tet_result( TET_FAIL );
1795   }
1796   catch ( DaliException& e )
1797   {
1798     DALI_TEST_ASSERT( e, "! \"GetProperty", TEST_LOCATION );
1799   }
1800   END_TEST;
1801 }
1802
1803 int UtcDaliPropertyRegistrationAddSameIndex(void)
1804 {
1805   TestApplication application;
1806   int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 100;
1807
1808   // Add one property with a valid property index
1809   PropertyRegistration property1( customType1, "propName",  propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
1810
1811   // Attempt to add another property with the same index
1812   try
1813   {
1814     PropertyRegistration property2( customType1, "propName2",   propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
1815   }
1816   catch ( DaliException& e )
1817   {
1818     DALI_TEST_ASSERT( e, "! \"Property index already added", TEST_LOCATION );
1819   }
1820
1821   int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 100;
1822
1823   // Add one property with a valid property index
1824   AnimatablePropertyRegistration property3( customType1, "animPropName",   animatablePropertyIndex, Property::BOOLEAN );
1825
1826   // Attempt to add another property with the same index
1827   try
1828   {
1829     AnimatablePropertyRegistration property4( customType1, "animPropName2",    animatablePropertyIndex, Property::BOOLEAN );
1830   }
1831   catch ( DaliException& e )
1832   {
1833     DALI_TEST_ASSERT( e, "! \"Property index already added", TEST_LOCATION );
1834   }
1835   END_TEST;
1836 }
1837
1838 int UtcDaliPropertyRegistrationPropertyWritableP(void)
1839 {
1840   TestApplication application;
1841   int propertyIndex1 = PROPERTY_REGISTRATION_START_INDEX + 200;
1842   int propertyIndex2 = PROPERTY_REGISTRATION_START_INDEX + 201;
1843
1844   // Add two properties, one with SetProperty, one without
1845   PropertyRegistration property1( customType1, "propNameReadwrite",   propertyIndex1, Property::BOOLEAN, &SetProperty, &GetProperty );
1846   PropertyRegistration property2( customType1, "propNameReadonly",    propertyIndex2, Property::BOOLEAN, NULL, &GetProperty );
1847
1848   // Create custom-actor
1849   TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
1850   DALI_TEST_CHECK( typeInfo );
1851   BaseHandle handle = typeInfo.CreateInstance();
1852   DALI_TEST_CHECK( handle );
1853   Actor customActor = Actor::DownCast( handle );
1854   DALI_TEST_CHECK( customActor );
1855
1856   // Check whether properties are writable
1857   DALI_TEST_CHECK(   customActor.IsPropertyWritable( propertyIndex1 ) );
1858   DALI_TEST_CHECK( ! customActor.IsPropertyWritable( propertyIndex2 ) );
1859
1860
1861   // Check the property is writable in the type registry
1862   Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
1863
1864   DALI_TEST_EQUALS( typeInfoImpl.IsPropertyWritable( propertyIndex1 ), true, TEST_LOCATION );
1865
1866   END_TEST;
1867 }
1868
1869 int UtcDaliPropertyRegistrationPropertyWritableN(void)
1870 {
1871   // Currently Actors don't register properties with the type registry
1872
1873   TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
1874   Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
1875
1876   try
1877   {
1878     typeInfoImpl.IsPropertyWritable( Actor::Property::COLOR);
1879     tet_result( TET_FAIL );
1880
1881   }
1882   catch ( DaliException& e )
1883   {
1884      DALI_TEST_ASSERT( e, "Cannot find property index", TEST_LOCATION );
1885   }
1886   END_TEST;
1887
1888 }
1889 int UtcDaliPropertyRegistrationPropertyAnimatable(void)
1890 {
1891   TestApplication application;
1892   int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 400;
1893   int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 400;
1894
1895   // These properties are not animatable
1896   PropertyRegistration property1( customType1, "propName",  propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
1897
1898   // These properties are animatable
1899   AnimatablePropertyRegistration property2( customType1, "animPropName",   animatablePropertyIndex, Property::BOOLEAN );
1900
1901   // Create custom-actor
1902   TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
1903   DALI_TEST_CHECK( typeInfo );
1904   BaseHandle handle = typeInfo.CreateInstance();
1905   DALI_TEST_CHECK( handle );
1906   Actor customActor = Actor::DownCast( handle );
1907   DALI_TEST_CHECK( customActor );
1908
1909   // Check if animatable
1910   DALI_TEST_CHECK( ! customActor.IsPropertyAnimatable( propertyIndex ) );
1911   DALI_TEST_CHECK( customActor.IsPropertyAnimatable( animatablePropertyIndex ) );
1912
1913   // Create another instance of custom-actor
1914   BaseHandle handle2 = typeInfo.CreateInstance();
1915   DALI_TEST_CHECK( handle2 );
1916   Actor customActor2 = Actor::DownCast( handle2 );
1917   DALI_TEST_CHECK( customActor2 );
1918
1919   // Check if animatable
1920   DALI_TEST_CHECK( ! customActor2.IsPropertyAnimatable( propertyIndex ) );
1921   DALI_TEST_CHECK( customActor2.IsPropertyAnimatable( animatablePropertyIndex ) );
1922   END_TEST;
1923 }
1924
1925 int UtcDaliPropertyRegistrationInvalidGetAndSet(void)
1926 {
1927   TestApplication application;
1928   int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 2000;
1929   int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2000;
1930
1931   // Create custom-actor
1932   TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
1933   DALI_TEST_CHECK( typeInfo );
1934   BaseHandle handle = typeInfo.CreateInstance();
1935   DALI_TEST_CHECK( handle );
1936   Actor customActor = Actor::DownCast( handle );
1937   DALI_TEST_CHECK( customActor );
1938
1939   // Try to set an index that hasn't been added
1940   try
1941   {
1942     customActor.SetProperty( propertyIndex, true );
1943     tet_result( TET_FAIL );
1944   }
1945   catch ( DaliException& e )
1946   {
1947     DALI_TEST_ASSERT( e, "! \"Cannot find property index", TEST_LOCATION );
1948   }
1949
1950   try
1951   {
1952     customActor.SetProperty( animatablePropertyIndex, true );
1953     tet_result( TET_FAIL );
1954   }
1955   catch ( DaliException& e )
1956   {
1957     DALI_TEST_ASSERT( e, "! \"Cannot find property index", TEST_LOCATION );
1958   }
1959
1960   // Try to get an index that hasn't been added
1961   try
1962   {
1963     (void) customActor.GetProperty< bool >( propertyIndex );
1964     tet_result( TET_FAIL );
1965   }
1966   catch ( DaliException& e )
1967   {
1968     DALI_TEST_ASSERT( e, "! \"Cannot find property index", TEST_LOCATION );
1969   }
1970
1971   try
1972   {
1973     (void) customActor.GetProperty< bool >( animatablePropertyIndex );
1974     tet_result( TET_FAIL );
1975   }
1976   catch ( DaliException& e )
1977   {
1978     DALI_TEST_ASSERT( e, "! \"Cannot find property index", TEST_LOCATION );
1979   }
1980   END_TEST;
1981 }
1982
1983
1984 int UtcDaliLongPressGestureDetectorTypeRegistry(void)
1985 {
1986   TestApplication application;
1987
1988   Actor actor = Actor::New();
1989   actor.SetSize(100.0f, 100.0f);
1990   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
1991   Stage::GetCurrent().Add(actor);
1992
1993   // Register Type
1994   TypeInfo type;
1995   type = TypeRegistry::Get().GetTypeInfo( "LongPressGestureDetector" );
1996   DALI_TEST_CHECK( type );
1997   BaseHandle handle = type.CreateInstance();
1998   DALI_TEST_CHECK( handle );
1999   LongPressGestureDetector detector = LongPressGestureDetector::DownCast( handle );
2000   DALI_TEST_CHECK( detector );
2001
2002   // Attach actor to detector
2003   SignalData data;
2004   GestureReceivedFunctor functor( data );
2005   detector.Attach(actor);
2006
2007   // Connect to signal through type
2008   handle.ConnectSignal( &application, "longPressDetected",   functor );
2009
2010   // Render and notify
2011   application.SendNotification();
2012   application.Render();
2013
2014   // Emit gesture
2015   application.ProcessEvent(GenerateLongPress(Gesture::Possible, 1u, Vector2(50.0f, 10.0f)));
2016   application.ProcessEvent(GenerateLongPress(Gesture::Started, 1u, Vector2(50.0f, 10.0f)));
2017   application.ProcessEvent(GenerateLongPress(Gesture::Finished, 1u, Vector2(50.0f, 10.0f)));
2018   DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
2019   END_TEST;
2020 }
2021
2022 int UtcDaliPanGestureDetectorTypeRegistry(void)
2023 {
2024   TestApplication application;
2025
2026   Actor actor = Actor::New();
2027   actor.SetSize(100.0f, 100.0f);
2028   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
2029   Stage::GetCurrent().Add(actor);
2030
2031   // Register Type
2032   TypeInfo type;
2033   type = TypeRegistry::Get().GetTypeInfo( "PanGestureDetector" );
2034   DALI_TEST_CHECK( type );
2035   BaseHandle handle = type.CreateInstance();
2036   DALI_TEST_CHECK( handle );
2037   PanGestureDetector detector = PanGestureDetector::DownCast( handle );
2038   DALI_TEST_CHECK( detector );
2039
2040   // Attach actor to detector
2041   SignalData data;
2042   GestureReceivedFunctor functor( data );
2043   detector.Attach(actor);
2044
2045   // Connect to signal through type
2046   handle.ConnectSignal( &application, "panDetected",  functor );
2047
2048   // Render and notify
2049   application.SendNotification();
2050   application.Render();
2051
2052   // Emit gesture
2053   application.ProcessEvent(GeneratePan(Gesture::Possible, Vector2(10.0f, 20.0f), Vector2(20.0f, 20.0f), 10));
2054   application.ProcessEvent(GeneratePan(Gesture::Started, Vector2(10.0f, 20.0f), Vector2(20.0f, 20.0f), 10));
2055   application.ProcessEvent(GeneratePan(Gesture::Finished, Vector2(10.0f, 20.0f), Vector2(20.0f, 20.0f), 10));
2056   DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
2057   END_TEST;
2058 }
2059
2060 int UtcDaliPinchGestureDetectorTypeRegistry(void)
2061 {
2062   TestApplication application;
2063
2064   Actor actor = Actor::New();
2065   actor.SetSize(100.0f, 100.0f);
2066   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
2067   Stage::GetCurrent().Add(actor);
2068
2069   // Register Type
2070   TypeInfo type;
2071   type = TypeRegistry::Get().GetTypeInfo( "PinchGestureDetector" );
2072   DALI_TEST_CHECK( type );
2073   BaseHandle handle = type.CreateInstance();
2074   DALI_TEST_CHECK( handle );
2075   PinchGestureDetector detector = PinchGestureDetector::DownCast( handle );
2076   DALI_TEST_CHECK( detector );
2077
2078   // Attach actor to detector
2079   SignalData data;
2080   GestureReceivedFunctor functor( data );
2081   detector.Attach(actor);
2082
2083   // Connect to signal through type
2084   handle.ConnectSignal( &application, "pinchDetected",  functor );
2085
2086   // Render and notify
2087   application.SendNotification();
2088   application.Render();
2089
2090   // Emit gesture
2091   application.ProcessEvent(GeneratePinch(Gesture::Started, 10.0f, 50.0f, Vector2(20.0f, 10.0f)));
2092   DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
2093   END_TEST;
2094 }
2095
2096 int UtcDaliTapGestureDetectorTypeRegistry(void)
2097 {
2098   TestApplication application;
2099
2100   Actor actor = Actor::New();
2101   actor.SetSize(100.0f, 100.0f);
2102   actor.SetAnchorPoint(AnchorPoint::TOP_LEFT);
2103   Stage::GetCurrent().Add(actor);
2104
2105   // Register Type
2106   TypeInfo type;
2107   type = TypeRegistry::Get().GetTypeInfo( "TapGestureDetector" );
2108   DALI_TEST_CHECK( type );
2109   BaseHandle handle = type.CreateInstance();
2110   DALI_TEST_CHECK( handle );
2111   TapGestureDetector detector = TapGestureDetector::DownCast( handle );
2112   DALI_TEST_CHECK( detector );
2113
2114   // Attach actor to detector
2115   SignalData data;
2116   GestureReceivedFunctor functor( data );
2117   detector.Attach(actor);
2118
2119   // Connect to signal through type
2120   handle.ConnectSignal( &application, "tapDetected",  functor );
2121
2122   // Render and notify
2123   application.SendNotification();
2124   application.Render();
2125
2126   // Emit gesture
2127   application.ProcessEvent(GenerateTap(Gesture::Possible, 1u, 1u, Vector2(50.0f, 10.0f)));
2128   application.ProcessEvent(GenerateTap(Gesture::Started, 1u, 1u, Vector2(50.0f, 10.0f)));
2129   DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
2130   END_TEST;
2131 }
2132
2133 int UtcDaliTypeRegistryNamedType(void)
2134 {
2135   TestApplication application;
2136   TypeRegistry typeRegistry = TypeRegistry::Get();
2137
2138   // Create a normal actor
2139   BaseHandle actorHandle = typeRegistry.GetTypeInfo( "Actor" ).CreateInstance();
2140   DALI_TEST_CHECK( actorHandle );
2141   Actor actor( Actor::DownCast( actorHandle ) );
2142   DALI_TEST_CHECK( actor );
2143   unsigned int actorPropertyCount( actor.GetPropertyCount() );
2144
2145   // Create Named Actor Type
2146   BaseHandle namedHandle = typeRegistry.GetTypeInfo( "MyNamedActor" ).CreateInstance();
2147   DALI_TEST_CHECK( namedHandle );
2148   Actor namedActor( Actor::DownCast( namedHandle ) );
2149   DALI_TEST_CHECK( namedActor );
2150   unsigned int namedActorPropertyCount( namedActor.GetPropertyCount() );
2151
2152   DALI_TEST_CHECK( namedActorPropertyCount > actorPropertyCount );
2153   END_TEST;
2154 }
2155
2156 int UtcDaliTypeInfoGetActionNameP(void)
2157 {
2158   TestApplication application;
2159   TypeRegistry typeRegistry = TypeRegistry::Get();
2160
2161   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2162   DALI_TEST_CHECK( typeInfo );
2163
2164   DALI_TEST_CHECK( 0 != typeInfo.GetActionCount() );
2165
2166   std::string name = typeInfo.GetActionName(0);
2167
2168   DALI_TEST_EQUALS( name, "show", TEST_LOCATION );
2169
2170
2171   TypeInfo typeInfo2 = typeRegistry.GetTypeInfo( "MyTestCustomActor" );
2172
2173   //  search for show action in base class, given a derived class
2174   bool foundChildAction = false;
2175   for( std::size_t i = 0; i < typeInfo2.GetActionCount(); i++ )
2176   {
2177
2178        std::string name = typeInfo2.GetActionName( i );
2179        if( name == "show")
2180        {
2181          foundChildAction = true;
2182        }
2183
2184   }
2185
2186   DALI_TEST_EQUALS( foundChildAction, true, TEST_LOCATION );
2187
2188
2189   END_TEST;
2190 }
2191
2192 int UtcDaliTypeInfoGetActionNameN(void)
2193 {
2194   TestApplication application;
2195   TypeRegistry typeRegistry = TypeRegistry::Get();
2196
2197   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2198   DALI_TEST_CHECK( typeInfo );
2199
2200   DALI_TEST_CHECK( 0 != typeInfo.GetActionCount() );
2201
2202   std::string name = typeInfo.GetActionName(std::numeric_limits<size_t>::max());
2203
2204   DALI_TEST_EQUALS( 0u, name.size(), TEST_LOCATION );
2205
2206   END_TEST;
2207 }
2208
2209 int UtcDaliTypeInfoGetSignalNameP(void)
2210 {
2211   TestApplication application;
2212   TypeRegistry typeRegistry = TypeRegistry::Get();
2213
2214   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2215   DALI_TEST_CHECK( typeInfo );
2216
2217   DALI_TEST_CHECK( 0 != typeInfo.GetSignalCount() );
2218
2219   std::string name = typeInfo.GetSignalName(0);
2220
2221   DALI_TEST_EQUALS( name, "touched", TEST_LOCATION );
2222
2223   TypeInfo typeInfo2 = typeRegistry.GetTypeInfo( "MyTestCustomActor" );
2224
2225   //  search for signal in base class, given a derived class
2226   bool foundSignal = false;
2227   for( std::size_t i = 0; i < typeInfo2.GetSignalCount(); i++ )
2228   {
2229
2230        std::string name = typeInfo2.GetSignalName( i );
2231        if( name == "touched")
2232        {
2233          foundSignal = true;
2234        }
2235
2236   }
2237
2238   DALI_TEST_EQUALS( foundSignal, true, TEST_LOCATION );
2239
2240   END_TEST;
2241 }
2242
2243 int UtcDaliTypeInfoGetSignalNameN(void)
2244 {
2245   TestApplication application;
2246   TypeRegistry typeRegistry = TypeRegistry::Get();
2247
2248   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2249   DALI_TEST_CHECK( typeInfo );
2250
2251   DALI_TEST_CHECK( 0 != typeInfo.GetSignalCount() );
2252
2253   std::string name = typeInfo.GetSignalName(std::numeric_limits<size_t>::max());
2254
2255   DALI_TEST_EQUALS( 0u, name.size(), TEST_LOCATION );
2256
2257   END_TEST;
2258 }
2259
2260
2261 int UtcDaliTypeInfoGetCreatorP(void)
2262 {
2263   TestApplication application;
2264   TypeRegistry typeRegistry = TypeRegistry::Get();
2265
2266   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2267   DALI_TEST_CHECK( typeInfo );
2268
2269   TypeInfo::CreateFunction createFn = typeInfo.GetCreator();
2270   DALI_TEST_EQUALS( createFn != NULL, true, TEST_LOCATION );
2271   if( createFn )
2272   {
2273     // try calling it:
2274     BaseHandle handle = createFn();
2275     DALI_TEST_EQUALS( (bool)handle, true, TEST_LOCATION );
2276   }
2277
2278   END_TEST;
2279 }
2280
2281 int UtcDaliTypeInfoGetCreatorN(void)
2282 {
2283   TestApplication application;
2284   TypeRegistry typeRegistry = TypeRegistry::Get();
2285
2286   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "MyTestCustomActor3" );
2287   DALI_TEST_CHECK( typeInfo );
2288
2289   TypeInfo::CreateFunction createFn = typeInfo.GetCreator();
2290   DALI_TEST_EQUALS( createFn == NULL, true, TEST_LOCATION );
2291
2292   END_TEST;
2293 }
2294
2295 int UtcDaliTypeInfoGetPropertyCountP1(void)
2296 {
2297   TestApplication application;
2298   TypeRegistry typeRegistry = TypeRegistry::Get();
2299
2300   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
2301   DALI_TEST_CHECK( typeInfo );
2302   size_t actorPropertyCount = typeInfo.GetPropertyCount();
2303
2304   DALI_TEST_EQUALS( actorPropertyCount == 0 , true, TEST_LOCATION ); // No event only props
2305   END_TEST;
2306 }
2307
2308 int UtcDaliTypeInfoGetPropertyCountP2(void)
2309 {
2310   TestApplication application;
2311   TypeRegistry typeRegistry = TypeRegistry::Get();
2312
2313   TypeInfo typeInfo = typeRegistry.GetTypeInfo( "MyTestCustomActor2" );
2314   DALI_TEST_CHECK( typeInfo );
2315   size_t propertyCount = typeInfo.GetPropertyCount();
2316   Property::IndexContainer indices;
2317   typeInfo.GetPropertyIndices( indices );
2318
2319   DALI_TEST_EQUALS( propertyCount > 0 && propertyCount <= indices.Size(), true, TEST_LOCATION );
2320   DALI_TEST_EQUALS( propertyCount == 2, true, TEST_LOCATION );
2321
2322   END_TEST;
2323 }
2324
2325 int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGet01(void)
2326 {
2327   TestApplication application;
2328   TypeRegistry typeRegistry = TypeRegistry::Get();
2329
2330   tet_infoline( "Register a type registered animatable property and ensure set/get behaviour works synchronously" );
2331
2332   // Register animatable property
2333   const int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
2334   AnimatablePropertyRegistration animatableProperty( customType1, "animatableProp1", animatablePropertyIndex, Property::FLOAT );
2335
2336   // Check property count before property registration
2337   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
2338   DALI_TEST_CHECK( typeInfo );
2339   BaseHandle handle = typeInfo.CreateInstance();
2340   DALI_TEST_CHECK( handle );
2341   Actor customActor = Actor::DownCast( handle );
2342   DALI_TEST_CHECK( customActor );
2343   Stage::GetCurrent().Add(customActor);
2344
2345   tet_infoline( "Set the value and ensure it changes straight away" );
2346   DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 0.0f, TEST_LOCATION );
2347   customActor.SetProperty( animatablePropertyIndex, 25.0f );
2348   DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 25.0f, TEST_LOCATION );
2349
2350   tet_infoline( "Check latest scene-graph value is unchanged" );
2351   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 0.0f, TEST_LOCATION );
2352
2353   // Render and notify
2354   application.SendNotification();
2355   application.Render();
2356
2357   tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
2358
2359   DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 25.0f, TEST_LOCATION );
2360   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 25.0f, TEST_LOCATION );
2361
2362   END_TEST;
2363 }
2364
2365 int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGetWithComponentsVector2(void)
2366 {
2367   TestApplication application;
2368   TypeRegistry typeRegistry = TypeRegistry::Get();
2369
2370   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" );
2371
2372   // Register the animatable propeties
2373   const int basePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
2374   const int componentZeroPropertyIndex( basePropertyIndex + 1 );
2375   const int componentOnePropertyIndex( componentZeroPropertyIndex + 1 );
2376   AnimatablePropertyRegistration baseAnimatableProperty( customType1, "baseProp", basePropertyIndex, Vector2( 13.0f, 24.0f ) );
2377   AnimatablePropertyComponentRegistration componentZeroAnimatableProperty( customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0 );
2378   AnimatablePropertyComponentRegistration componentOneAnimatableProperty( customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1 );
2379
2380   // Check property count before property registration
2381   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
2382   DALI_TEST_CHECK( typeInfo );
2383   BaseHandle handle = typeInfo.CreateInstance();
2384   DALI_TEST_CHECK( handle );
2385   Actor customActor = Actor::DownCast( handle );
2386   DALI_TEST_CHECK( customActor );
2387   Stage::GetCurrent().Add(customActor);
2388
2389   tet_infoline( "Get the component values, they should be the default value of the base-property" );
2390   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2391   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2392   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 13.0f, 24.0f ), TEST_LOCATION );
2393
2394   tet_infoline( "Set a component value and ensure it changes for the base property as well" );
2395   customActor.SetProperty( componentZeroPropertyIndex, 125.0f );
2396   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2397   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 24.0f ), TEST_LOCATION );
2398
2399   customActor.SetProperty( componentOnePropertyIndex, 225.0f );
2400   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2401   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 225.0f ), TEST_LOCATION );
2402
2403   tet_infoline( "Check latest scene-graph value is unchanged" );
2404   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( basePropertyIndex ), Vector2( 13.0f, 24.0f ), TEST_LOCATION );
2405   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2406   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2407
2408   // Render and notify
2409   application.SendNotification();
2410   application.Render();
2411
2412   tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
2413   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 225.0f ), TEST_LOCATION );
2414   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2415   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2416
2417   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 225.0f ), TEST_LOCATION );
2418   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2419   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2420
2421   tet_infoline( "Set the base property value and ensure the component values reflect the change" );
2422   customActor.SetProperty( basePropertyIndex, Vector2( 1.0f, 2.0f ) );
2423   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 1.0f, TEST_LOCATION );
2424   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 2.0f, TEST_LOCATION );
2425   DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 1.0f, 2.0f ), TEST_LOCATION );
2426
2427   END_TEST;
2428 }
2429
2430 int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGetWithComponentsVector3(void)
2431 {
2432   TestApplication application;
2433   TypeRegistry typeRegistry = TypeRegistry::Get();
2434
2435   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" );
2436
2437   // Register the animatable propeties
2438   const int basePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
2439   const int componentZeroPropertyIndex( basePropertyIndex + 1 );
2440   const int componentOnePropertyIndex( componentZeroPropertyIndex + 1 );
2441   const int componentTwoPropertyIndex( componentOnePropertyIndex + 1 );
2442   AnimatablePropertyRegistration baseAnimatableProperty( customType1, "baseProp", basePropertyIndex, Vector3( 13.0f, 24.0f, 35.0 ) );
2443   AnimatablePropertyComponentRegistration componentZeroAnimatableProperty( customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0 );
2444   AnimatablePropertyComponentRegistration componentOneAnimatableProperty( customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1 );
2445   AnimatablePropertyComponentRegistration componentTwoAnimatableProperty( customType1, "componentTwoProp", componentTwoPropertyIndex, basePropertyIndex, 2 );
2446
2447   // Check property count before property registration
2448   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
2449   DALI_TEST_CHECK( typeInfo );
2450   BaseHandle handle = typeInfo.CreateInstance();
2451   DALI_TEST_CHECK( handle );
2452   Actor customActor = Actor::DownCast( handle );
2453   DALI_TEST_CHECK( customActor );
2454   Stage::GetCurrent().Add(customActor);
2455
2456   tet_infoline( "Get the component values, they should be the default value of the base-property" );
2457   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2458   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2459   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
2460   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 13.0f, 24.0f, 35.0f ), TEST_LOCATION );
2461
2462   tet_infoline( "Set a component value and ensure it changes for the base property as well" );
2463   customActor.SetProperty( componentZeroPropertyIndex, 125.0f );
2464   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2465   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 24.0f, 35.0f ), TEST_LOCATION );
2466
2467   customActor.SetProperty( componentOnePropertyIndex, 225.0f );
2468   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2469   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 35.0f ), TEST_LOCATION );
2470
2471   customActor.SetProperty( componentTwoPropertyIndex, 325.0f );
2472   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2473   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 325.0f ), TEST_LOCATION );
2474
2475   tet_infoline( "Check latest scene-graph value is unchanged" );
2476   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector3 >( basePropertyIndex ), Vector3( 13.0f, 24.0f, 35.0f ), TEST_LOCATION );
2477   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2478   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2479   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
2480
2481   // Render and notify
2482   application.SendNotification();
2483   application.Render();
2484
2485   tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
2486   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 325.0f ), TEST_LOCATION );
2487   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2488   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2489   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2490
2491   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 325.0f ), TEST_LOCATION );
2492   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2493   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2494   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2495
2496   tet_infoline( "Set the base property value and ensure the component values reflect the change" );
2497   customActor.SetProperty( basePropertyIndex, Vector3( 1.0f, 2.0f, 3.0f ) );
2498   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 1.0f, TEST_LOCATION );
2499   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 2.0f, TEST_LOCATION );
2500   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 3.0f, TEST_LOCATION );
2501   DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 1.0f, 2.0f, 3.0f ), TEST_LOCATION );
2502
2503   END_TEST;
2504 }
2505
2506 int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGetWithComponentsVector4(void)
2507 {
2508   TestApplication application;
2509   TypeRegistry typeRegistry = TypeRegistry::Get();
2510
2511   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" );
2512
2513   // Register the animatable propeties
2514   const int basePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
2515   const int componentZeroPropertyIndex( basePropertyIndex + 1 );
2516   const int componentOnePropertyIndex( componentZeroPropertyIndex + 1 );
2517   const int componentTwoPropertyIndex( componentOnePropertyIndex + 1 );
2518   const int componentThreePropertyIndex( componentTwoPropertyIndex + 1 );
2519   AnimatablePropertyRegistration baseAnimatableProperty( customType1, "baseProp", basePropertyIndex, Vector4( 13.0f, 24.0f, 35.0, 47.0f ) );
2520   AnimatablePropertyComponentRegistration componentZeroAnimatableProperty( customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0 );
2521   AnimatablePropertyComponentRegistration componentOneAnimatableProperty( customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1 );
2522   AnimatablePropertyComponentRegistration componentTwoAnimatableProperty( customType1, "componentTwoProp", componentTwoPropertyIndex, basePropertyIndex, 2 );
2523   AnimatablePropertyComponentRegistration componentThreeAnimatableProperty( customType1, "componentThreeProp", componentThreePropertyIndex, basePropertyIndex, 3 );
2524
2525   // Check property count before property registration
2526   TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
2527   DALI_TEST_CHECK( typeInfo );
2528   BaseHandle handle = typeInfo.CreateInstance();
2529   DALI_TEST_CHECK( handle );
2530   Actor customActor = Actor::DownCast( handle );
2531   DALI_TEST_CHECK( customActor );
2532   Stage::GetCurrent().Add(customActor);
2533
2534   tet_infoline( "Get the component values, they should be the default value of the base-property" );
2535   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2536   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2537   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
2538   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 47.0f, TEST_LOCATION );
2539   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 13.0f, 24.0f, 35.0f, 47.0f ), TEST_LOCATION );
2540
2541   tet_infoline( "Set a component value and ensure it changes for the base property as well" );
2542   customActor.SetProperty( componentZeroPropertyIndex, 125.0f );
2543   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2544   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 24.0f, 35.0f, 47.0f ), TEST_LOCATION );
2545
2546   customActor.SetProperty( componentOnePropertyIndex, 225.0f );
2547   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2548   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 35.0f, 47.0f ), TEST_LOCATION );
2549
2550   customActor.SetProperty( componentTwoPropertyIndex, 325.0f );
2551   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2552   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 47.0f ), TEST_LOCATION );
2553
2554   customActor.SetProperty( componentThreePropertyIndex, 435.0f );
2555   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 435.0f, TEST_LOCATION );
2556   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 435.0f ), TEST_LOCATION );
2557
2558   tet_infoline( "Check latest scene-graph value is unchanged" );
2559   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector4 >( basePropertyIndex ), Vector4( 13.0f, 24.0f, 35.0f, 47.0f ), TEST_LOCATION );
2560   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
2561   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
2562   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
2563   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentThreePropertyIndex ), 47.0f, TEST_LOCATION );
2564
2565   // Render and notify
2566   application.SendNotification();
2567   application.Render();
2568
2569   tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
2570   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 435.0f ), TEST_LOCATION );
2571   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2572   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2573   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2574   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 435.0f, TEST_LOCATION );
2575
2576   DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 435.0f ), TEST_LOCATION );
2577   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
2578   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
2579   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
2580   DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentThreePropertyIndex ), 435.0f, TEST_LOCATION );
2581
2582   tet_infoline( "Set the base property value and ensure the component values reflect the change" );
2583   customActor.SetProperty( basePropertyIndex, Vector4( 1.0f, 2.0f, 3.0f, 4.0f ) );
2584   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 1.0f, TEST_LOCATION );
2585   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 2.0f, TEST_LOCATION );
2586   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 3.0f, TEST_LOCATION );
2587   DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 4.0f, TEST_LOCATION );
2588   DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 1.0f, 2.0f, 3.0f, 4.0f ), TEST_LOCATION );
2589
2590   END_TEST;
2591 }