automated-tests/src/dali/utc-Dali-Animation.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 <algorithm>
  20
  21 #include <stdlib.h>
  22 #include <dali/public-api/dali-core.h>
  23 #include <dali/devel-api/actors/actor-devel.h>
  24 #include <dali/devel-api/object/handle-devel.h>
  25 #include <dali-test-suite-utils.h>
  26
  27 using std::max;
  28 using namespace Dali;
  29
  30 void utc_dali_animation_startuP(void)
  31 {
  32   test_return_value = TET_UNDEF;
  33 }
  34
  35 void utc_dali_animation_cleanuP(void)
  36 {
  37   test_return_value = TET_PASS;
  38 }
  39
  40 namespace
  41 {
  42
  43 static const float ROTATION_EPSILON = 0.0001f;
  44 static const float VECTOR4_EPSILON = 0.0001f;
  45
  46 // Functor to test whether a Finish signal is emitted
  47 struct AnimationFinishCheck
  48 {
  49   AnimationFinishCheck(bool& signalReceived)
  50   : mSignalReceived(signalReceived)
  51   {
  52   }
  53
  54   void operator()(Animation& animation)
  55   {
  56     mSignalReceived = true;
  57   }
  58
  59   void Reset()
  60   {
  61     mSignalReceived = false;
  62   }
  63
  64   void CheckSignalReceived()
  65   {
  66     if (!mSignalReceived)
  67     {
  68       tet_printf("Expected Finish signal was not received\n");
  69       tet_result(TET_FAIL);
  70     }
  71     else
  72     {
  73       tet_result(TET_PASS);
  74     }
  75   }
  76
  77   void CheckSignalNotReceived()
  78   {
  79     if (mSignalReceived)
  80     {
  81       tet_printf("Unexpected Finish signal was received\n");
  82       tet_result(TET_FAIL);
  83     }
  84     else
  85     {
  86       tet_result(TET_PASS);
  87     }
  88   }
  89
  90   bool& mSignalReceived; // owned by individual tests
  91 };
  92
  93 } // anon namespace
  94
  95 int UtcDaliAnimationConstructorP(void)
  96 {
  97   TestApplication application;
  98
  99   Animation animation;
 100
 101   DALI_TEST_CHECK( !animation );
 102   END_TEST;
 103 }
 104
 105 int UtcDaliAnimationNewP(void)
 106 {
 107   TestApplication application;
 108
 109   Animation animation = Animation::New( 1.0f );
 110
 111   DALI_TEST_CHECK(animation);
 112   END_TEST;
 113 }
 114
 115 int UtcDaliAnimationNewN(void)
 116 {
 117   TestApplication application;
 118
 119   Animation animation = Animation::New( -1.0f );
 120
 121   DALI_TEST_CHECK(animation);
 122   DALI_TEST_EQUALS(animation.GetDuration(), 0.0f, TEST_LOCATION);
 123   END_TEST;
 124 }
 125
 126 int UtcDaliAnimationDownCastP(void)
 127 {
 128   TestApplication application;
 129
 130   tet_infoline("Testing Dali::Animation::DownCast()");
 131
 132   float durationSeconds(1.0f);
 133   Animation animation = Animation::New(durationSeconds);
 134
 135   BaseHandle object(animation);
 136
 137   Animation animation2 = Animation::DownCast(object);
 138   DALI_TEST_CHECK(animation2);
 139
 140   Animation animation3 = DownCast< Animation >(object);
 141   DALI_TEST_CHECK(animation3);
 142   END_TEST;
 143 }
 144
 145 int UtcDaliAnimationDownCastN(void)
 146 {
 147   TestApplication application;
 148
 149   BaseHandle unInitializedObject;
 150
 151   Animation animation1 = Animation::DownCast( unInitializedObject );
 152   DALI_TEST_CHECK( !animation1 );
 153
 154   Animation animation2 = DownCast< Animation >( unInitializedObject );
 155   DALI_TEST_CHECK( !animation2 );
 156   END_TEST;
 157 }
 158
 159 int UtcDaliAnimationCopyConstructorP(void)
 160 {
 161   TestApplication application;
 162
 163   // Initialize an object, ref count == 1
 164   Animation animation = Animation::New( 1.0f );
 165
 166   Animation copy( animation );
 167   DALI_TEST_CHECK( copy );
 168
 169   DALI_TEST_CHECK( copy.GetDuration() == animation.GetDuration() );
 170   END_TEST;
 171 }
 172
 173 int UtcDaliAnimationAssignmentOperatorP(void)
 174 {
 175   TestApplication application;
 176
 177   Animation animation = Animation::New( 1.0f );
 178
 179   Animation copy = animation;
 180   DALI_TEST_CHECK( copy );
 181
 182   DALI_TEST_CHECK( animation == copy );
 183
 184   DALI_TEST_CHECK( copy.GetDuration() == animation.GetDuration() );
 185   END_TEST;
 186 }
 187
 188 int UtcDaliAnimationSetDurationP(void)
 189 {
 190   TestApplication application;
 191
 192   Actor actor = Actor::New();
 193   Stage::GetCurrent().Add(actor);
 194
 195   // Build the animation
 196   float durationSeconds(1.0f);
 197   Animation animation = Animation::New(durationSeconds);
 198   DALI_TEST_EQUALS(animation.GetDuration(), durationSeconds, TEST_LOCATION);
 199
 200   // Start the animation
 201   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 202   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 203   animation.Play();
 204
 205   bool signalReceived(false);
 206   AnimationFinishCheck finishCheck(signalReceived);
 207   animation.FinishedSignal().Connect(&application, finishCheck);
 208
 209   application.SendNotification();
 210   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
 211
 212   // We didn't expect the animation to finish yet
 213   application.SendNotification();
 214   finishCheck.CheckSignalNotReceived();
 215
 216   application.Render(2u/*just beyond the animation duration*/);
 217
 218   // We did expect the animation to finish
 219   application.SendNotification();
 220   finishCheck.CheckSignalReceived();
 221   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 222
 223   // Restart the animation, with a different duration
 224   finishCheck.Reset();
 225   actor.SetPosition(Vector3::ZERO);
 226   durationSeconds = 3.5f;
 227   animation.SetDuration(durationSeconds);
 228   DALI_TEST_EQUALS(animation.GetDuration(), durationSeconds, TEST_LOCATION);
 229   animation.Play();
 230
 231   application.SendNotification();
 232   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
 233
 234   // We didn't expect the animation to finish yet
 235   application.SendNotification();
 236   finishCheck.CheckSignalNotReceived();
 237
 238   application.Render(2u/*just beyond the animation duration*/);
 239
 240   // We did expect the animation to finish
 241   application.SendNotification();
 242   finishCheck.CheckSignalReceived();
 243   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 244
 245   // Check that nothing has changed after a couple of buffer swaps
 246   application.Render(0);
 247   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 248   application.Render(0);
 249   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 250   END_TEST;
 251 }
 252
 253 int UtcDaliAnimationSetDurationN(void)
 254 {
 255   TestApplication application;
 256
 257   Animation animation = Animation::New( 1.0f );
 258   DALI_TEST_EQUALS( animation.GetDuration(), 1.0f, TEST_LOCATION );
 259
 260   animation.SetDuration( -1.0f );
 261   DALI_TEST_EQUALS( animation.GetDuration(), 0.0f, TEST_LOCATION );
 262   END_TEST;
 263 }
 264
 265 int UtcDaliAnimationGetDurationP(void)
 266 {
 267   TestApplication application;
 268
 269   Animation animation = Animation::New(1.0f);
 270   DALI_TEST_EQUALS(animation.GetDuration(), 1.0f, TEST_LOCATION);
 271
 272   animation.SetDuration(2.0f);
 273   DALI_TEST_EQUALS(animation.GetDuration(), 2.0f, TEST_LOCATION);
 274   END_TEST;
 275 }
 276
 277 int UtcDaliAnimationSetLoopingP(void)
 278 {
 279   TestApplication application;
 280
 281   Actor actor = Actor::New();
 282   Stage::GetCurrent().Add(actor);
 283
 284   // Build the animation
 285   float durationSeconds(1.0f);
 286   Animation animation = Animation::New(durationSeconds);
 287   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 288   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 289
 290   // Start the animation
 291   animation.SetLooping(true);
 292   DALI_TEST_CHECK(animation.IsLooping());
 293   animation.Play();
 294
 295   bool signalReceived(false);
 296   AnimationFinishCheck finishCheck(signalReceived);
 297   animation.FinishedSignal().Connect(&application, finishCheck);
 298
 299   application.SendNotification();
 300
 301   // Loop 5 times
 302   float intervalSeconds = 0.25f;
 303   float progress = 0.0f;
 304   for (int iterations = 0; iterations < 5;)
 305   {
 306     application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 307
 308     progress += intervalSeconds;
 309     DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentPosition(), 0.001f, TEST_LOCATION );
 310
 311     if (progress >= 1.0f)
 312     {
 313       progress = progress - 1.0f;
 314       ++iterations;
 315     }
 316   }
 317
 318   // We didn't expect the animation to finish yet
 319   application.SendNotification();
 320   finishCheck.CheckSignalNotReceived();
 321
 322   animation.SetLooping(false);
 323   DALI_TEST_CHECK(!animation.IsLooping());
 324
 325   application.SendNotification();
 326   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
 327
 328   // We did expect the animation to finish
 329   application.SendNotification();
 330   finishCheck.CheckSignalReceived();
 331   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 332
 333   // Check that nothing has changed after a couple of buffer swaps
 334   application.Render(0);
 335   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 336   application.Render(0);
 337   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 338   END_TEST;
 339 }
 340
 341 int UtcDaliAnimationSetLoopCountP(void)
 342 {
 343   TestApplication application;
 344
 345   Actor actor = Actor::New();
 346   Stage::GetCurrent().Add(actor);
 347
 348   // Build the animation
 349   float durationSeconds(1.0f);
 350   Animation animation = Animation::New(durationSeconds);
 351   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 352   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 353
 354   // Start the animation
 355   animation.SetLoopCount(3);
 356   DALI_TEST_CHECK(animation.IsLooping());
 357   animation.Play();
 358
 359   bool signalReceived(false);
 360   AnimationFinishCheck finishCheck(signalReceived);
 361   animation.FinishedSignal().Connect(&application, finishCheck);
 362
 363   application.Render(0);
 364   application.SendNotification();
 365   application.Render(0);
 366   application.SendNotification();
 367   application.Render(0);
 368   application.SendNotification();
 369   application.Render(0);
 370   application.SendNotification();
 371
 372   // Loop
 373   float intervalSeconds = 3.0f;
 374
 375   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 376   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 377
 378   application.Render(0);
 379   application.SendNotification();
 380   application.Render(0);
 381   application.SendNotification();
 382   application.Render(0);
 383   application.SendNotification();
 384   application.Render(0);
 385   application.SendNotification();
 386   finishCheck.CheckSignalNotReceived();
 387
 388   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 389
 390   application.SendNotification();
 391   finishCheck.CheckSignalReceived();
 392   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 393
 394   finishCheck.Reset();
 395
 396   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 397   application.SendNotification();
 398   finishCheck.CheckSignalNotReceived();
 399
 400   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 401   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 402   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 403   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 404   application.SendNotification();
 405   finishCheck.CheckSignalNotReceived();
 406
 407   END_TEST;
 408 }
 409
 410 int UtcDaliAnimationSetLoopCountP2(void)
 411 {
 412   TestApplication application;
 413
 414   //
 415   // switching between forever and loop count
 416   //
 417
 418   Actor actor = Actor::New();
 419   Stage::GetCurrent().Add(actor);
 420
 421   // Build the animation
 422   float durationSeconds(1.0f);
 423   Animation animation = Animation::New(durationSeconds);
 424   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 425   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 426   animation.SetEndAction(Animation::Discard);
 427
 428   // Start the animation
 429   animation.SetLoopCount(3);
 430   DALI_TEST_CHECK(animation.IsLooping());
 431   animation.Play();
 432
 433   bool signalReceived(false);
 434   AnimationFinishCheck finishCheck(signalReceived);
 435   animation.FinishedSignal().Connect(&application, finishCheck);
 436
 437   float intervalSeconds = 3.0f;
 438
 439   application.SendNotification();
 440   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 441   application.SendNotification();
 442   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 443   application.SendNotification();
 444   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 445   application.SendNotification();
 446
 447   application.SendNotification();
 448   finishCheck.CheckSignalReceived();
 449
 450   finishCheck.Reset();
 451
 452   // Loop forever
 453   animation.SetLooping(true);
 454   DALI_TEST_CHECK(animation.IsLooping());
 455
 456   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 457   application.SendNotification();
 458   finishCheck.CheckSignalNotReceived();
 459
 460   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 461   application.SendNotification();
 462   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 463   application.SendNotification();
 464   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 465   application.SendNotification();
 466   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 467   application.SendNotification();
 468   application.SendNotification();
 469   finishCheck.CheckSignalNotReceived();
 470
 471   finishCheck.Reset();
 472
 473   // Loop N again
 474   animation.SetLoopCount(3);
 475   DALI_TEST_CHECK(animation.IsLooping());
 476   animation.Play();
 477
 478   application.SendNotification();
 479   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 480   application.SendNotification();
 481   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 482   application.SendNotification();
 483   finishCheck.CheckSignalNotReceived();
 484
 485   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 486   application.SendNotification();
 487   finishCheck.CheckSignalReceived();
 488
 489   finishCheck.Reset();
 490
 491   // loop forever
 492   animation.SetLooping(true);
 493   DALI_TEST_CHECK(animation.IsLooping());
 494
 495   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 496   application.SendNotification();
 497   finishCheck.CheckSignalNotReceived();
 498
 499   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 500   application.SendNotification();
 501   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 502   application.SendNotification();
 503   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 504   application.SendNotification();
 505   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 506   application.SendNotification();
 507   finishCheck.CheckSignalNotReceived();
 508
 509   finishCheck.Reset();
 510
 511   // Loop N again
 512   animation.SetLoopCount(3);
 513   DALI_TEST_CHECK(animation.IsLooping());
 514
 515   application.SendNotification();
 516   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 517   application.SendNotification();
 518   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 519   application.SendNotification();
 520   finishCheck.CheckSignalNotReceived();
 521
 522   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 523   application.SendNotification();
 524   finishCheck.CheckSignalNotReceived(); // we never hit play
 525
 526   finishCheck.Reset();
 527
 528
 529   END_TEST;
 530 }
 531
 532 int UtcDaliAnimationSetLoopCountP3(void)
 533 {
 534   TestApplication application;
 535
 536   //
 537   // switching between forever and loop count
 538   //
 539   Actor actor = Actor::New();
 540   Stage::GetCurrent().Add(actor);
 541
 542   // Build the animation
 543   float durationSeconds(1.0f);
 544   Animation animation = Animation::New(durationSeconds);
 545   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 546   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 547   animation.SetEndAction(Animation::Discard);
 548
 549   float intervalSeconds = 3.0f;
 550
 551   bool signalReceived(false);
 552   AnimationFinishCheck finishCheck(signalReceived);
 553   animation.FinishedSignal().Connect(&application, finishCheck);
 554
 555   // loop forever
 556   animation.SetLooping(true);
 557   DALI_TEST_CHECK(animation.IsLooping());
 558
 559   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 560   application.SendNotification();
 561   finishCheck.CheckSignalNotReceived();
 562
 563   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 564   application.SendNotification();
 565   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 566   application.SendNotification();
 567   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 568   application.SendNotification();
 569   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 570   application.SendNotification();
 571   finishCheck.CheckSignalNotReceived();
 572
 573   finishCheck.Reset();
 574
 575   // Loop N again
 576   animation.SetLoopCount(3);
 577   DALI_TEST_CHECK(animation.IsLooping());
 578
 579   application.SendNotification();
 580   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 581   application.SendNotification();
 582   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 583   application.SendNotification();
 584   finishCheck.CheckSignalNotReceived();
 585
 586   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 587   application.SendNotification();
 588   finishCheck.CheckSignalNotReceived(); // we never hit play
 589
 590   finishCheck.Reset();
 591
 592
 593   END_TEST;
 594 }
 595
 596 int UtcDaliAnimationSetLoopCountP4(void)
 597 {
 598   TestApplication application;
 599
 600   //
 601   // ..and play again
 602   //
 603   Actor actor = Actor::New();
 604   Stage::GetCurrent().Add(actor);
 605
 606   // Build the animation
 607   float durationSeconds(1.0f);
 608   Animation animation = Animation::New(durationSeconds);
 609   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 610   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 611   animation.SetEndAction(Animation::Bake);
 612
 613   float intervalSeconds = 3.0f;
 614
 615   bool signalReceived(false);
 616   AnimationFinishCheck finishCheck(signalReceived);
 617   animation.FinishedSignal().Connect(&application, finishCheck);
 618
 619   animation.SetLoopCount(1);
 620   animation.Play();
 621   DALI_TEST_CHECK(!animation.IsLooping());
 622
 623   application.SendNotification();
 624   finishCheck.CheckSignalNotReceived();
 625   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 626   application.SendNotification();
 627   finishCheck.CheckSignalReceived();
 628
 629   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
 630   actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f) );
 631
 632   finishCheck.Reset();
 633
 634   animation.Play(); // again
 635   DALI_TEST_CHECK(!animation.IsLooping());
 636
 637   application.SendNotification();
 638   finishCheck.CheckSignalNotReceived();
 639   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 640   application.SendNotification();
 641   finishCheck.CheckSignalReceived();
 642
 643   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
 644
 645   END_TEST;
 646 }
 647
 648 int UtcDaliAnimationGetLoopCountP(void)
 649 {
 650   TestApplication application;
 651
 652   Actor actor = Actor::New();
 653   Stage::GetCurrent().Add(actor);
 654
 655   // Build the animation
 656   float durationSeconds(1.0f);
 657   Animation animation = Animation::New(durationSeconds);
 658   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 659   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 660
 661   DALI_TEST_CHECK(1 == animation.GetLoopCount());
 662
 663   // Start the animation
 664   animation.SetLoopCount(3);
 665   DALI_TEST_CHECK(animation.IsLooping());
 666   DALI_TEST_CHECK(3 == animation.GetLoopCount());
 667
 668   animation.Play();
 669
 670   application.Render(0);
 671   application.SendNotification();
 672
 673   // Loop
 674   float intervalSeconds = 3.0f;
 675
 676   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 677   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 678
 679   application.Render(0);
 680   application.SendNotification();
 681
 682   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 683   application.SendNotification();
 684
 685   animation.SetLoopCount(0);
 686   DALI_TEST_CHECK(animation.IsLooping());
 687   DALI_TEST_CHECK(0 == animation.GetLoopCount());
 688
 689   animation.SetLoopCount(1);
 690   DALI_TEST_CHECK(!animation.IsLooping());
 691   DALI_TEST_CHECK(1 == animation.GetLoopCount());
 692
 693   END_TEST;
 694 }
 695
 696
 697 int UtcDaliAnimationGetCurrentLoopP(void)
 698 {
 699   TestApplication application;
 700
 701   Actor actor = Actor::New();
 702   Stage::GetCurrent().Add(actor);
 703
 704   // Build the animation
 705   float durationSeconds(1.0f);
 706   Animation animation = Animation::New(durationSeconds);
 707   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 708   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 709
 710   // Start the animation
 711   animation.SetLoopCount(3);
 712   DALI_TEST_CHECK(animation.IsLooping());
 713   DALI_TEST_CHECK(0 == animation.GetCurrentLoop());
 714   animation.Play();
 715
 716   bool signalReceived(false);
 717   AnimationFinishCheck finishCheck(signalReceived);
 718   animation.FinishedSignal().Connect(&application, finishCheck);
 719
 720   application.SendNotification();
 721
 722   // Loop
 723   float intervalSeconds = 3.0f;
 724
 725   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 726   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 727
 728   application.SendNotification();
 729   finishCheck.CheckSignalNotReceived();
 730   DALI_TEST_CHECK(2 == animation.GetCurrentLoop());
 731
 732   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 733
 734   application.SendNotification();
 735   finishCheck.CheckSignalReceived();
 736   DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
 737   DALI_TEST_CHECK(animation.GetLoopCount() == animation.GetCurrentLoop());
 738
 739   finishCheck.Reset();
 740
 741   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 742   application.SendNotification();
 743   finishCheck.CheckSignalNotReceived();
 744   DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
 745
 746   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 747   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 748   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 749   application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
 750   application.SendNotification();
 751   finishCheck.CheckSignalNotReceived();
 752   DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
 753
 754   END_TEST;
 755 }
 756
 757 int UtcDaliAnimationIsLoopingP(void)
 758 {
 759   TestApplication application;
 760
 761   Animation animation = Animation::New(1.0f);
 762   DALI_TEST_CHECK(!animation.IsLooping());
 763
 764   animation.SetLooping(true);
 765   DALI_TEST_CHECK(animation.IsLooping());
 766   END_TEST;
 767 }
 768
 769 int UtcDaliAnimationSetEndActioN(void)
 770 {
 771   TestApplication application;
 772
 773   Actor actor = Actor::New();
 774   Stage::GetCurrent().Add(actor);
 775
 776   // Build the animation
 777   float durationSeconds(1.0f);
 778   Animation animation = Animation::New(durationSeconds);
 779   DALI_TEST_CHECK(animation.GetEndAction() == Animation::Bake);
 780
 781   Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 782   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 783
 784   // Start the animation
 785   animation.Play();
 786
 787   bool signalReceived(false);
 788   AnimationFinishCheck finishCheck(signalReceived);
 789   animation.FinishedSignal().Connect(&application, finishCheck);
 790
 791   application.SendNotification();
 792   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
 793
 794   // We did expect the animation to finish
 795   application.SendNotification();
 796   finishCheck.CheckSignalReceived();
 797   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 798
 799   // Go back to the start
 800   actor.SetPosition(Vector3::ZERO);
 801   application.SendNotification();
 802   application.Render(0);
 803   DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentPosition(), TEST_LOCATION );
 804
 805   // Test BakeFinal, animate again, for half the duration
 806   finishCheck.Reset();
 807   animation.SetEndAction(Animation::BakeFinal);
 808   DALI_TEST_CHECK(animation.GetEndAction() == Animation::BakeFinal);
 809   animation.Play();
 810
 811   application.SendNotification();
 812   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f*0.5f) /*half of the animation duration*/);
 813
 814   // Stop the animation early
 815   animation.Stop();
 816
 817   // We did NOT expect the animation to finish
 818   application.SendNotification();
 819   finishCheck.CheckSignalNotReceived();
 820   DALI_TEST_EQUALS( targetPosition * 0.5f, actor.GetCurrentPosition(), VECTOR4_EPSILON, TEST_LOCATION );
 821
 822   // The position should be same with target position in the next frame
 823   application.Render(0);
 824   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 825
 826   // Go back to the start
 827   actor.SetPosition(Vector3::ZERO);
 828   application.SendNotification();
 829   application.Render(0);
 830   DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentPosition(), TEST_LOCATION );
 831
 832   // Test EndAction::Discard, animate again, but don't bake this time
 833   finishCheck.Reset();
 834   animation.SetEndAction(Animation::Discard);
 835   DALI_TEST_CHECK(animation.GetEndAction() == Animation::Discard);
 836   animation.Play();
 837
 838   application.SendNotification();
 839   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
 840
 841   // We did expect the animation to finish
 842   application.SendNotification();
 843   finishCheck.CheckSignalReceived();
 844   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
 845
 846   // The position should be discarded in the next frame
 847   application.Render(0);
 848   DALI_TEST_EQUALS( Vector3::ZERO/*discarded*/, actor.GetCurrentPosition(), TEST_LOCATION );
 849
 850   // Check that nothing has changed after a couple of buffer swaps
 851   application.Render(0);
 852   DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentPosition(), TEST_LOCATION );
 853   application.Render(0);
 854   DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentPosition(), TEST_LOCATION );
 855   END_TEST;
 856 }
 857
 858 int UtcDaliAnimationGetEndActionP(void)
 859 {
 860   TestApplication application;
 861
 862   Animation animation = Animation::New(1.0f);
 863   DALI_TEST_CHECK(animation.GetEndAction() == Animation::Bake);
 864
 865   animation.SetEndAction(Animation::Discard);
 866   DALI_TEST_CHECK(animation.GetEndAction() == Animation::Discard);
 867
 868   animation.SetEndAction(Animation::BakeFinal);
 869   DALI_TEST_CHECK(animation.GetEndAction() == Animation::BakeFinal);
 870
 871   END_TEST;
 872 }
 873
 874 int UtcDaliAnimationSetDisconnectActionP(void)
 875 {
 876   TestApplication application;
 877   Stage stage( Stage::GetCurrent() );
 878
 879   // Default: BakeFinal
 880   {
 881     Actor actor = Actor::New();
 882     stage.Add(actor);
 883
 884     // Build the animation
 885     float durationSeconds(1.0f);
 886     Animation animation = Animation::New(durationSeconds);
 887     DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::BakeFinal);
 888
 889     Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 890     animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 891
 892     // Start the animation
 893     animation.Play();
 894
 895     application.SendNotification();
 896     application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
 897
 898     actor.Unparent();
 899
 900     application.SendNotification();
 901     application.Render();
 902
 903     DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
 904   }
 905
 906   // Bake
 907   {
 908     Actor actor = Actor::New();
 909     stage.Add(actor);
 910
 911     // Build the animation
 912     float durationSeconds(1.0f);
 913     Animation animation = Animation::New(durationSeconds);
 914     animation.SetDisconnectAction( Animation::Bake );
 915
 916     Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 917     animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 918
 919     // Start the animation
 920     animation.Play();
 921
 922     application.SendNotification();
 923     application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
 924
 925     actor.Unparent();
 926
 927     application.SendNotification();
 928     application.Render();
 929
 930     DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition*0.5f, TEST_LOCATION );
 931   }
 932
 933   // Discard
 934   {
 935     Actor actor = Actor::New();
 936     stage.Add(actor);
 937
 938     // Build the animation
 939     float durationSeconds(1.0f);
 940     Animation animation = Animation::New(durationSeconds);
 941     animation.SetDisconnectAction( Animation::Discard );
 942
 943     Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 944     animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 945
 946     // Start the animation
 947     animation.Play();
 948
 949     application.SendNotification();
 950     application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
 951
 952     actor.Unparent();
 953
 954     application.SendNotification();
 955     application.Render();
 956
 957     DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
 958   }
 959
 960   // Don't play the animation: disconnect action should not be applied
 961   {
 962     Actor actor = Actor::New();
 963     stage.Add(actor);
 964
 965     // Build the animation
 966     float durationSeconds(1.0f);
 967     Animation animation = Animation::New(durationSeconds);
 968
 969     Vector3 targetPosition(10.0f, 10.0f, 10.0f);
 970     animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
 971
 972     application.SendNotification();
 973     application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
 974
 975     actor.Unparent();
 976
 977     application.SendNotification();
 978     application.Render();
 979
 980     DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
 981   }
 982
 983   END_TEST;
 984 }
 985
 986 int UtcDaliAnimationGetDisconnectActionP(void)
 987 {
 988   TestApplication application;
 989   Animation animation = Animation::New(1.0f);
 990   DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::BakeFinal); // default!
 991
 992   animation.SetDisconnectAction(Animation::Discard);
 993   DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::Discard);
 994
 995   animation.SetDisconnectAction(Animation::Bake);
 996   DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::Bake);
 997
 998   END_TEST;
 999 }
1000
1001 int UtcDaliAnimationSetDefaultAlphaFunctionP(void)
1002 {
1003   TestApplication application;
1004
1005   Animation animation = Animation::New(1.0f);
1006   AlphaFunction func = animation.GetDefaultAlphaFunction();
1007   DALI_TEST_EQUALS(func.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
1008
1009   animation.SetDefaultAlphaFunction(AlphaFunction::EASE_IN);
1010   AlphaFunction func2 = animation.GetDefaultAlphaFunction();
1011   DALI_TEST_EQUALS(func2.GetBuiltinFunction(), AlphaFunction::EASE_IN, TEST_LOCATION);
1012   END_TEST;
1013 }
1014
1015 int UtcDaliAnimationGetDefaultAlphaFunctionP(void)
1016 {
1017   TestApplication application;
1018
1019   Animation animation = Animation::New(1.0f);
1020   AlphaFunction func = animation.GetDefaultAlphaFunction();
1021
1022   // Test that the default is linear
1023   DALI_TEST_EQUALS(func.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
1024
1025   animation.SetDefaultAlphaFunction(AlphaFunction::EASE_IN);
1026   AlphaFunction func2 = animation.GetDefaultAlphaFunction();
1027   DALI_TEST_EQUALS(func2.GetBuiltinFunction(), AlphaFunction::EASE_IN, TEST_LOCATION);
1028
1029   END_TEST;
1030 }
1031
1032 int UtcDaliAnimationSetCurrentProgressP(void)
1033 {
1034   TestApplication application;
1035
1036   Actor actor = Actor::New();
1037   Stage::GetCurrent().Add(actor);
1038
1039   // Build the animation
1040   Animation animation = Animation::New(0.0f);
1041
1042   //Set duration
1043   float durationSeconds(1.0f);
1044   animation.SetDuration(durationSeconds);
1045
1046   bool signalReceived(false);
1047   AnimationFinishCheck finishCheck(signalReceived);
1048   animation.FinishedSignal().Connect(&application, finishCheck);
1049   application.SendNotification();
1050
1051   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1052   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
1053
1054   // Start the animation from 40% progress
1055   animation.SetCurrentProgress( 0.4f );
1056   animation.Play();
1057
1058   application.SendNotification();
1059   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
1060
1061   // We didn't expect the animation to finish yet
1062   application.SendNotification();
1063   finishCheck.CheckSignalNotReceived();
1064   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
1065   DALI_TEST_EQUALS( 0.6f, animation.GetCurrentProgress(), TEST_LOCATION );
1066
1067   animation.Play(); // Test that calling play has no effect, when animation is already playing
1068   application.SendNotification();
1069
1070   //Set the progress to 70%
1071   animation.SetCurrentProgress( 0.7f );
1072   application.SendNotification();
1073   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 80% progress */);
1074   DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
1075
1076   application.SendNotification();
1077   finishCheck.CheckSignalNotReceived();
1078   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
1079   DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
1080
1081   application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
1082   // We did expect the animation to finish
1083   application.SendNotification();
1084   finishCheck.CheckSignalReceived();
1085   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
1086
1087   // Check that nothing has changed after a couple of buffer swaps
1088   application.Render(0);
1089   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1090   application.Render(0);
1091   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1092   END_TEST;
1093 }
1094
1095 int UtcDaliAnimationSetCurrentProgressN(void)
1096 {
1097   TestApplication application;
1098
1099   Actor actor = Actor::New();
1100   Stage::GetCurrent().Add(actor);
1101
1102   // Build the animation
1103   Animation animation = Animation::New(0.0f);
1104
1105   //Set duration
1106   float durationSeconds(1.0f);
1107   animation.SetDuration(durationSeconds);
1108
1109   bool signalReceived(false);
1110   AnimationFinishCheck finishCheck(signalReceived);
1111   animation.FinishedSignal().Connect(&application, finishCheck);
1112   application.SendNotification();
1113
1114   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1115   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
1116
1117   //Trying to set the current cursor outside the range [0..1] is ignored
1118   animation.SetCurrentProgress( -1.0f);
1119   application.SendNotification();
1120   DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
1121
1122   animation.SetCurrentProgress( 100.0f);
1123   application.SendNotification();
1124   DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
1125   END_TEST;
1126 }
1127
1128 int UtcDaliAnimationGetCurrentProgressP(void)
1129 {
1130   TestApplication application;
1131
1132   Actor actor = Actor::New();
1133   Stage::GetCurrent().Add(actor);
1134
1135   // Build the animation
1136   Animation animation = Animation::New(0.0f);
1137   animation.Play();
1138
1139   //Test GetCurrentProgress return 0.0 as the duration is 0.0
1140   DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
1141
1142   animation.SetCurrentProgress( 0.5f );
1143   application.SendNotification();
1144   application.Render(static_cast<unsigned int>(100.0f));
1145
1146   //Progress should still be 0.0
1147   DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
1148
1149   //Set duration
1150   float durationSeconds(1.0f);
1151   animation.SetDuration(durationSeconds);
1152   application.SendNotification();
1153
1154   bool signalReceived(false);
1155   AnimationFinishCheck finishCheck(signalReceived);
1156   animation.FinishedSignal().Connect(&application, finishCheck);
1157   application.SendNotification();
1158
1159   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1160   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
1161
1162   // Start the animation from 40% progress
1163   animation.SetCurrentProgress( 0.4f );
1164   animation.Play();
1165
1166   application.SendNotification();
1167   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
1168
1169   // We didn't expect the animation to finish yet
1170   application.SendNotification();
1171   finishCheck.CheckSignalNotReceived();
1172   DALI_TEST_EQUALS( 0.6f, animation.GetCurrentProgress(), TEST_LOCATION );
1173
1174   animation.Play(); // Test that calling play has no effect, when animation is already playing
1175   application.SendNotification();
1176
1177   //Set the progress to 70%
1178   animation.SetCurrentProgress( 0.7f );
1179   application.SendNotification();
1180   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 80% progress */);
1181   DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
1182
1183   application.SendNotification();
1184   finishCheck.CheckSignalNotReceived();
1185   DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
1186
1187   application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
1188   // We did expect the animation to finish
1189   application.SendNotification();
1190   finishCheck.CheckSignalReceived();
1191   END_TEST;
1192 }
1193
1194 int UtcDaliAnimationSetSpeedFactorP1(void)
1195 {
1196   TestApplication application;
1197
1198   tet_printf("Testing that setting a speed factor of 2 takes half the time\n");
1199
1200   Actor actor = Actor::New();
1201   Stage::GetCurrent().Add(actor);
1202
1203   // Build the animation
1204   float durationSeconds(1.0f);
1205   Animation animation = Animation::New(durationSeconds);
1206
1207   const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
1208   const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1209
1210   KeyFrames keyframes = KeyFrames::New();
1211   keyframes.Add( 0.0f, initialPosition);
1212   keyframes.Add( 1.0f, targetPosition );
1213   animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1214
1215   //Set speed to be x2
1216   animation.SetSpeedFactor(2.0f);
1217
1218   // Start the animation
1219   animation.Play();
1220
1221   bool signalReceived(false);
1222   AnimationFinishCheck finishCheck(signalReceived);
1223   animation.FinishedSignal().Connect(&application, finishCheck);
1224
1225   application.SendNotification();
1226   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
1227
1228   // We didn't expect the animation to finish yet
1229   application.SendNotification();
1230   finishCheck.CheckSignalNotReceived();
1231   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
1232
1233   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
1234
1235   // We didn't expect the animation to finish yet
1236   application.SendNotification();
1237   finishCheck.CheckSignalNotReceived();
1238   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
1239
1240   application.Render(static_cast<unsigned int>(durationSeconds*100.0f) + 1u/*just beyond half the duration*/);
1241
1242   // We did expect the animation to finish
1243   application.SendNotification();
1244   finishCheck.CheckSignalReceived();
1245   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
1246
1247   // Check that nothing has changed after a couple of buffer swaps
1248   application.Render(0);
1249   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1250   application.Render(0);
1251   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1252
1253   END_TEST;
1254 }
1255
1256 int UtcDaliAnimationSetSpeedFactorP2(void)
1257 {
1258   TestApplication application;
1259
1260   Actor actor = Actor::New();
1261   Stage::GetCurrent().Add(actor);
1262
1263   // Build the animation
1264   float durationSeconds(1.0f);
1265   Animation animation = Animation::New(durationSeconds);
1266
1267   const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
1268   const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1269
1270   KeyFrames keyframes = KeyFrames::New();
1271   keyframes.Add( 0.0f, initialPosition);
1272   keyframes.Add( 1.0f, targetPosition );
1273   animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1274
1275   tet_printf("Test -1 speed factor. Animation will play in reverse at normal speed\n");
1276   animation.SetSpeedFactor( -1.0f );
1277
1278   // Start the animation
1279   animation.Play();
1280
1281   bool signalReceived(false);
1282   AnimationFinishCheck finishCheck(signalReceived);
1283   animation.FinishedSignal().Connect(&application, finishCheck);
1284
1285   application.SendNotification();
1286   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
1287
1288   // We didn't expect the animation to finish yet
1289   application.SendNotification();
1290   finishCheck.CheckSignalNotReceived();
1291   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
1292
1293   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
1294
1295   // We didn't expect the animation to finish yet
1296   application.SendNotification();
1297   finishCheck.CheckSignalNotReceived();
1298   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
1299
1300   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
1301
1302   // We didn't expect the animation to finish yet
1303   application.SendNotification();
1304   finishCheck.CheckSignalNotReceived();
1305   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
1306
1307   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
1308
1309   // We didn't expect the animation to finish yet
1310   application.SendNotification();
1311   finishCheck.CheckSignalNotReceived();
1312   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
1313
1314   application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
1315
1316   // We did expect the animation to finish
1317   application.SendNotification();
1318   finishCheck.CheckSignalReceived();
1319   DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
1320
1321   // Check that nothing has changed after a couple of buffer swaps
1322   application.Render(0);
1323   DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1324   application.Render(0);
1325   DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1326
1327   END_TEST;
1328 }
1329
1330 int UtcDaliAnimationSetSpeedFactorP3(void)
1331 {
1332   TestApplication application;
1333
1334   Actor actor = Actor::New();
1335   Stage::GetCurrent().Add(actor);
1336
1337   // Build the animation
1338   float durationSeconds(1.0f);
1339   Animation animation = Animation::New(durationSeconds);
1340
1341   const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
1342   const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1343
1344   KeyFrames keyframes = KeyFrames::New();
1345   keyframes.Add( 0.0f, initialPosition);
1346   keyframes.Add( 1.0f, targetPosition );
1347   animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1348
1349   bool signalReceived(false);
1350   AnimationFinishCheck finishCheck(signalReceived);
1351   animation.FinishedSignal().Connect(&application, finishCheck);
1352
1353   tet_printf("Test half speed factor. Animation will take twice the duration\n");
1354
1355   //Set speed to be half of normal speed
1356   animation.SetSpeedFactor( 0.5f );
1357
1358   // Start the animation
1359   animation.Play();
1360
1361   application.SendNotification();
1362   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
1363
1364   // We didn't expect the animation to finish yet
1365   application.SendNotification();
1366   finishCheck.CheckSignalNotReceived();
1367   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.1f), TEST_LOCATION );
1368
1369   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
1370
1371   // We didn't expect the animation to finish yet
1372   application.SendNotification();
1373   finishCheck.CheckSignalNotReceived();
1374   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
1375
1376   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
1377
1378   // We didn't expect the animation to finish yet
1379   application.SendNotification();
1380   finishCheck.CheckSignalNotReceived();
1381   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.3f), TEST_LOCATION );
1382
1383   application.SendNotification();
1384   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
1385
1386   // We didn't expect the animation to finish yet
1387   application.SendNotification();
1388   finishCheck.CheckSignalNotReceived();
1389   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
1390
1391   application.Render(static_cast<unsigned int>(durationSeconds*1200.0f) + 1u/*just beyond the animation duration*/);
1392
1393   // We did expect the animation to finish
1394   application.SendNotification();
1395   finishCheck.CheckSignalReceived();
1396   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
1397
1398   // Check that nothing has changed after a couple of buffer swaps
1399   application.Render(0);
1400   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1401   application.Render(0);
1402   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1403   END_TEST;
1404 }
1405
1406
1407 int UtcDaliAnimationSetSpeedFactorP4(void)
1408 {
1409   TestApplication application;
1410
1411   Actor actor = Actor::New();
1412   Stage::GetCurrent().Add(actor);
1413
1414   // Build the animation
1415   float durationSeconds(1.0f);
1416   Animation animation = Animation::New(durationSeconds);
1417
1418   const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
1419   const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1420
1421   KeyFrames keyframes = KeyFrames::New();
1422   keyframes.Add( 0.0f, initialPosition);
1423   keyframes.Add( 1.0f, targetPosition );
1424   animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1425
1426   bool signalReceived(false);
1427   AnimationFinishCheck finishCheck(signalReceived);
1428   animation.FinishedSignal().Connect(&application, finishCheck);
1429
1430   tet_printf("Test half speed factor. Animation will take twice the duration\n");
1431
1432   tet_printf("Set speed to be half of normal speed\n");
1433   tet_printf("SetSpeedFactor(0.5f)\n");
1434   animation.SetSpeedFactor( 0.5f );
1435
1436   // Start the animation
1437   animation.Play();
1438
1439   application.SendNotification();
1440   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
1441
1442   // We didn't expect the animation to finish yet
1443   application.SendNotification();
1444   finishCheck.CheckSignalNotReceived();
1445   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.1f), TEST_LOCATION );
1446
1447   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
1448
1449   // We didn't expect the animation to finish yet
1450   application.SendNotification();
1451   finishCheck.CheckSignalNotReceived();
1452   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
1453
1454   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
1455
1456   // We didn't expect the animation to finish yet
1457   application.SendNotification();
1458   finishCheck.CheckSignalNotReceived();
1459   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.3f), TEST_LOCATION );
1460
1461   tet_printf("Reverse direction of animation whilst playing\n");
1462   tet_printf("SetSpeedFactor(-0.5f)\n");
1463   animation.SetSpeedFactor(-0.5f);
1464
1465   application.SendNotification();
1466   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
1467
1468   // We didn't expect the animation to finish yet
1469   application.SendNotification();
1470   finishCheck.CheckSignalNotReceived();
1471   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
1472
1473   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
1474
1475   // We didn't expect the animation to finish yet
1476   application.SendNotification();
1477   finishCheck.CheckSignalNotReceived();
1478   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.1f), 0.0001, TEST_LOCATION );
1479
1480   application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
1481
1482   // We did expect the animation to finish
1483   application.SendNotification();
1484   finishCheck.CheckSignalReceived();
1485   DALI_TEST_EQUALS( actor.GetCurrentPosition(), initialPosition, TEST_LOCATION );
1486
1487   // Check that nothing has changed after a couple of buffer swaps
1488   application.Render(0);
1489   DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1490   application.Render(0);
1491   DALI_TEST_EQUALS( initialPosition, actor.GetCurrentPosition(), TEST_LOCATION );
1492   END_TEST;
1493 }
1494
1495 int UtcDaliAnimationSetSpeedFactorAndRange(void)
1496 {
1497   TestApplication application;
1498
1499   const unsigned int NUM_FRAMES(15);
1500
1501   struct TestData
1502   {
1503     float startTime;
1504     float endTime;
1505     float startX;
1506     float endX;
1507     float expected[NUM_FRAMES];
1508   };
1509
1510   TestData testData[] = {
1511     // ACTOR 0
1512     /*0.0f,   0.1f   0.2f   0.3f   0.4f   0.5f   0.6f   0.7f   0.8f   0.9f   1.0f */
1513     /*                       |----------PlayRange---------------|                 */
1514     /*                                            | reverse                       */
1515     { 0.0f,                                                                  1.0f, // TimePeriod
1516       0.0f,                                                                100.0f, // POS
1517       {/**/                 30.0f, 40.0f, 50.0f, 60.0f, 70.0f,  /* Loop */
1518        /**/                 30.0f, 40.0f, 50.0f, 60.0f, /* Reverse direction */
1519        /**/                               50.0f,
1520        /**/                        40.0f,
1521        /**/                 30.0f,
1522        /**/                                             70.0f,
1523        /**/                                      60.0f,
1524        /**/                               50.0f,
1525        /**/
1526       }
1527     },
1528
1529     // ACTOR 1 - Across start of range
1530     /*0.0f,   0.1f   0.2f   0.3f   0.4f   0.5f   0.6f   0.7f   0.8f   0.9f   1.0f */
1531     /*                       |----------PlayRange---------------|                 */
1532     /*                                            | reverse                       */
1533     {                0.2f,                0.5f,                               // TimePeriod
1534                      20.0f,               50.0f,                // POS
1535       {/**/                 30.0f, 40.0f, 50.0f, 50.0f, 50.0f,  /* Loop */
1536        /**/                 30.0f, 40.0f, 50.0f, 50.0f, /* Reverse direction @ frame #9 */
1537        /**/                               50.0f,
1538        /**/                        40.0f,
1539        /**/                 30.0f,
1540        /**/                                             50.0f,
1541        /**/                                      50.0f,
1542        /**/                               50.0f
1543       }
1544     },
1545
1546     // ACTOR 2 - Across end of range
1547     /*0.0f,   0.1f   0.2f   0.3f   0.4f   0.5f   0.6f   0.7f   0.8f   0.9f   1.0f */
1548     /*                       |----------PlayRange---------------|                 */
1549     /*                                            | reverse                       */
1550     {/**/                                  0.5f,                      0.9f,   // TimePeriod
1551      /**/                                 50.0f,                      90.0f,  // POS
1552      { /**/                 50.0f, 50.0f, 50.0f, 60.0f, 70.0f, /* Loop */
1553        /**/                 50.0f, 50.0f, 50.0f, 60.0f,/* Reverse direction @ frame #9 */
1554        /**/                               50.0f,
1555        /**/                        50.0f,
1556        /**/                 50.0f,                      70.0f,
1557        /**/                                      60.0f,
1558        /**/                               50.0f,
1559       }
1560     },
1561
1562     // ACTOR 3 - Before beginning of range
1563     /*0.0f,   0.1f   0.2f   0.3f   0.4f   0.5f   0.6f   0.7f   0.8f   0.9f   1.0f */
1564     /*                       |----------PlayRange---------------|                 */
1565     /*                                            | reverse                       */
1566     {/**/     0.1f,      0.25f, // TimePeriod
1567      /**/     10.0f,     25.0f, // POS
1568      { /**/
1569        /**/ 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f
1570        /**/
1571       }
1572     },
1573
1574     // ACTOR 4 - After end of range
1575     /*0.0f,   0.1f   0.2f   0.3f   0.4f   0.5f   0.6f   0.7f   0.8f   0.9f   1.0f */
1576     /*                       |----------PlayRange---------------|                 */
1577     /*                                            | reverse                       */
1578     {/**/                                                           0.85f,   1.0f, // TimePeriod
1579      /**/                                                           85.0f,  100.0f, // POS
1580      { /**/
1581        /**/ 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f
1582        /**/
1583      }
1584     },
1585     // Actor 5 - Middle of range
1586     /*0.0f,   0.1f   0.2f   0.3f   0.4f   0.5f   0.6f   0.7f   0.8f   0.9f   1.0f */
1587     /*                       |----------PlayRange---------------|                 */
1588     /*                                            | reverse                       */
1589     {/**/                          0.4f,            0.65f, // Time Period
1590      /**/                         40.0f,            65.0f, // Position
1591      { /**/                40.0f, 40.0f, 50.0f, 60.0f, 65.0f,
1592        /**/                40.0f, 40.0f, 50.0f, 60.0f, // Reverse
1593        /**/                              50.0f,
1594        /**/                       40.0f,
1595        /**/                40.0f,
1596        /**/                                            65.0f,
1597        /**/                                      60.0f,
1598        /**/                              50.0f,
1599      }
1600     }
1601   };
1602
1603   const size_t NUM_ENTRIES(sizeof(testData)/sizeof(TestData));
1604
1605   // Build the animation
1606   float durationSeconds(1.0f);
1607   Animation animation = Animation::New(durationSeconds);
1608   bool signalReceived(false);
1609   AnimationFinishCheck finishCheck(signalReceived);
1610   animation.FinishedSignal().Connect(&application, finishCheck);
1611
1612   std::vector<Dali::Actor> actors;
1613
1614   for( unsigned int actorIndex = 0; actorIndex < NUM_ENTRIES; ++actorIndex )
1615   {
1616     Actor actor = Actor::New();
1617     actor.SetPosition( Vector3( testData[actorIndex].startX, 0, 0 ) );
1618     actors.push_back(actor);
1619     Stage::GetCurrent().Add(actor);
1620
1621     if( actorIndex == 0 || actorIndex == NUM_ENTRIES-1 )
1622     {
1623       KeyFrames keyframes = KeyFrames::New();
1624       keyframes.Add( testData[actorIndex].startTime, Vector3(testData[actorIndex].startX, 0, 0));
1625       keyframes.Add( testData[actorIndex].endTime, Vector3(testData[actorIndex].endX, 0, 0));
1626       animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1627     }
1628     else
1629     {
1630       animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( testData[actorIndex].endX, 0, 0 ), TimePeriod( testData[actorIndex].startTime, testData[actorIndex].endTime - testData[actorIndex].startTime) );
1631     }
1632   }
1633
1634   tet_printf("Test half speed factor. Animation will take twice the duration\n");
1635   tet_printf("Set play range to be 0.3 - 0.8 of the duration\n");
1636   tet_printf("SetSpeedFactor(0.5f)\n");
1637   animation.SetSpeedFactor( 0.5f );
1638   animation.SetPlayRange( Vector2(0.3f, 0.8f) );
1639   animation.SetLooping(true);
1640
1641   // Start the animation
1642   animation.Play();
1643   application.SendNotification();
1644   application.Render(0);   // Frame 0 tests initial values
1645
1646   for( unsigned int frame = 0; frame < NUM_FRAMES; ++frame )
1647   {
1648     unsigned int actorIndex = 0u;
1649     for( actorIndex = 0u; actorIndex < NUM_ENTRIES; ++actorIndex )
1650     {
1651       DALI_TEST_EQUALS( actors[actorIndex].GetCurrentPosition().x, testData[actorIndex].expected[frame], 0.001, TEST_LOCATION );
1652       if( ! Equals(actors[actorIndex].GetCurrentPosition().x, testData[actorIndex].expected[frame]) )
1653       {
1654         tet_printf("Failed at frame %u, actorIndex %u\n", frame, actorIndex );
1655       }
1656     }
1657
1658     if( frame == 8 )
1659     {
1660       tet_printf("Reverse direction of animation whilst playing after frame 8\n");
1661       tet_printf("SetSpeedFactor(-0.5f)\n");
1662       animation.SetSpeedFactor(-0.5f);
1663       application.SendNotification();
1664     }
1665     application.Render(200); // 200 ms at half speed corresponds to 0.1 s
1666
1667     // We didn't expect the animation to finish yet
1668     application.SendNotification();
1669     finishCheck.CheckSignalNotReceived();
1670   }
1671
1672   END_TEST;
1673 }
1674
1675 int UtcDaliAnimationSetSpeedFactorRangeAndLoopCount01(void)
1676 {
1677   TestApplication application;
1678
1679   const unsigned int NUM_FRAMES(15);
1680
1681   struct TestData
1682   {
1683     float startTime;
1684     float endTime;
1685     float startX;
1686     float endX;
1687     float expected[NUM_FRAMES];
1688   };
1689
1690   TestData testData =
1691     // ACTOR 0
1692     /*0.0f,   0.1f   0.2f   0.3f   0.4f   0.5f   0.6f   0.7f   0.8f   0.9f   1.0f */
1693     /*                       |----------PlayRange---------------|                 */
1694     { 0.0f,                                                                  1.0f, // TimePeriod
1695       0.0f,                                                                100.0f, // POS
1696       {/**/                 30.0f, 40.0f, 50.0f, 60.0f, 70.0f,  /* Loop */
1697        /**/                 30.0f, 40.0f, 50.0f, 60.0f, 70.0f,
1698        /**/                 30.0f, 40.0f, 50.0f, 60.0f, 70.0f,
1699        /**/
1700       }
1701     };
1702
1703
1704   // Build the animation
1705   float durationSeconds(1.0f);
1706   Animation animation = Animation::New(durationSeconds);
1707   bool signalReceived(false);
1708   AnimationFinishCheck finishCheck(signalReceived);
1709   animation.FinishedSignal().Connect(&application, finishCheck);
1710
1711   std::vector<Dali::Actor> actors;
1712
1713   Actor actor = Actor::New();
1714   actor.SetPosition( Vector3( testData.startX, 0, 0 ) );
1715   actors.push_back(actor);
1716   Stage::GetCurrent().Add(actor);
1717
1718   KeyFrames keyframes = KeyFrames::New();
1719   keyframes.Add( testData.startTime, Vector3(testData.startX, 0, 0));
1720   keyframes.Add( testData.endTime, Vector3(testData.endX, 0, 0));
1721   animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1722
1723   tet_printf("Test half speed factor. Animation will take twice the duration\n");
1724   tet_printf("Set play range to be 0.3 - 0.8 of the duration\n");
1725   tet_printf("SetSpeedFactor(0.5f)\n");
1726   tet_printf("SetLoopCount(3)\n");
1727   animation.SetSpeedFactor( 0.5f );
1728   animation.SetPlayRange( Vector2(0.3f, 0.8f) );
1729   animation.SetLoopCount(3);
1730
1731   // Start the animation
1732   animation.Play();
1733   application.SendNotification();
1734   application.Render(0);   // Frame 0 tests initial values
1735
1736   for( unsigned int frame = 0; frame < NUM_FRAMES; ++frame )
1737   {
1738     DALI_TEST_EQUALS( actor.GetCurrentPosition().x, testData.expected[frame], 0.001, TEST_LOCATION );
1739
1740     application.Render(200); // 200 ms at half speed corresponds to 0.1 s
1741
1742     if( frame < NUM_FRAMES-1 )
1743     {
1744       // We didn't expect the animation to finish yet
1745       application.SendNotification();
1746       finishCheck.CheckSignalNotReceived();
1747     }
1748   }
1749
1750   // We did expect the animation to finish
1751   application.SendNotification();
1752   finishCheck.CheckSignalReceived();
1753   DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 80.0f, 0.001, TEST_LOCATION );
1754
1755   END_TEST;
1756 }
1757
1758 int UtcDaliAnimationSetSpeedFactorRangeAndLoopCount02(void)
1759 {
1760   TestApplication application;
1761
1762   const unsigned int NUM_FRAMES(15);
1763
1764   struct TestData
1765   {
1766     float startTime;
1767     float endTime;
1768     float startX;
1769     float endX;
1770     float expected[NUM_FRAMES];
1771   };
1772
1773   TestData testData =
1774     // ACTOR 0
1775     /*0.0f,   0.1f   0.2f   0.3f   0.4f   0.5f   0.6f   0.7f   0.8f   0.9f   1.0f */
1776     /*                       |----------PlayRange---------------|                 */
1777     { 0.0f,                                                                  1.0f, // TimePeriod
1778       0.0f,                                                                100.0f, // POS
1779       {/**/                 80.0f, 70.0f, 60.0f, 50.0f, 40.0f,
1780        /**/                 80.0f, 70.0f, 60.0f, 50.0f, 40.0f,
1781        /**/                 80.0f, 70.0f, 60.0f, 50.0f, 40.0f,
1782       }
1783     };
1784
1785
1786   // Build the animation
1787   float durationSeconds(1.0f);
1788   Animation animation = Animation::New(durationSeconds);
1789   bool signalReceived(false);
1790   AnimationFinishCheck finishCheck(signalReceived);
1791   animation.FinishedSignal().Connect(&application, finishCheck);
1792
1793   std::vector<Dali::Actor> actors;
1794
1795   Actor actor = Actor::New();
1796   actor.SetPosition( Vector3( testData.startX, 0, 0 ) );
1797   actors.push_back(actor);
1798   Stage::GetCurrent().Add(actor);
1799
1800   KeyFrames keyframes = KeyFrames::New();
1801   keyframes.Add( testData.startTime, Vector3(testData.startX, 0, 0));
1802   keyframes.Add( testData.endTime, Vector3(testData.endX, 0, 0));
1803   animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
1804
1805   tet_printf("Test reverse half speed factor. Animation will take twice the duration\n");
1806   tet_printf("Set play range to be 0.3 - 0.8 of the duration\n");
1807   tet_printf("SetSpeedFactor(-0.5f)\n");
1808   tet_printf("SetLoopCount(3)\n");
1809   animation.SetSpeedFactor( -0.5f );
1810   animation.SetPlayRange( Vector2(0.3f, 0.8f) );
1811   animation.SetLoopCount(3);
1812
1813   // Start the animation
1814   animation.Play();
1815   application.SendNotification();
1816   application.Render(0);   // Frame 0 tests initial values
1817
1818   for( unsigned int frame = 0; frame < NUM_FRAMES; ++frame )
1819   {
1820     DALI_TEST_EQUALS( actor.GetCurrentPosition().x, testData.expected[frame], 0.001, TEST_LOCATION );
1821
1822     application.Render(200); // 200 ms at half speed corresponds to 0.1 s
1823
1824     if( frame < NUM_FRAMES-1 )
1825     {
1826       // We didn't expect the animation to finish yet
1827       application.SendNotification();
1828       finishCheck.CheckSignalNotReceived();
1829     }
1830   }
1831
1832   // We did expect the animation to finish
1833   application.SendNotification();
1834   finishCheck.CheckSignalReceived();
1835   DALI_TEST_EQUALS( actor.GetCurrentPosition().x, 30.0f, 0.001, TEST_LOCATION );
1836
1837   END_TEST;
1838 }
1839
1840
1841 int UtcDaliAnimationGetSpeedFactorP(void)
1842 {
1843   TestApplication application;
1844
1845   Animation animation = Animation::New(1.0f);
1846   animation.SetSpeedFactor(0.5f);
1847   DALI_TEST_EQUALS(animation.GetSpeedFactor(), 0.5f, TEST_LOCATION);
1848
1849   animation.SetSpeedFactor(-2.5f);
1850   DALI_TEST_EQUALS(animation.GetSpeedFactor(), -2.5f, TEST_LOCATION);
1851   END_TEST;
1852 }
1853
1854 int UtcDaliAnimationSetPlayRangeP(void)
1855 {
1856   TestApplication application;
1857
1858   Actor actor = Actor::New();
1859   Stage::GetCurrent().Add( actor );
1860
1861   // Build the animation
1862   float durationSeconds( 1.0f );
1863   Animation animation = Animation::New( durationSeconds );
1864
1865   bool signalReceived( false );
1866   AnimationFinishCheck finishCheck( signalReceived );
1867   animation.FinishedSignal().Connect( &application, finishCheck );
1868   application.SendNotification();
1869
1870   // Set range between 0.4 and 0.8
1871   animation.SetPlayRange( Vector2( 0.4f, 0.9f ) );
1872   application.SendNotification();
1873   DALI_TEST_EQUALS( Vector2( 0.4f, 0.9f ), animation.GetPlayRange(), TEST_LOCATION );
1874
1875   Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
1876   animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR );
1877
1878   // Start the animation from 40% progress
1879   animation.Play();
1880
1881   application.SendNotification();
1882   application.Render( static_cast< unsigned int >( durationSeconds * 200.0f )/* 60% progress */ );
1883
1884   // We didn't expect the animation to finish yet
1885   application.SendNotification();
1886   finishCheck.CheckSignalNotReceived();
1887   DALI_TEST_EQUALS( actor.GetCurrentPosition(), ( targetPosition * 0.6f ), TEST_LOCATION );
1888
1889   application.SendNotification();
1890   application.Render( static_cast< unsigned int >( durationSeconds * 200.0f )/* 80% progress */ );
1891
1892   application.SendNotification();
1893   finishCheck.CheckSignalNotReceived();
1894   DALI_TEST_EQUALS( actor.GetCurrentPosition(), ( targetPosition * 0.8f ), TEST_LOCATION );
1895
1896   application.SendNotification();
1897   application.Render( static_cast< unsigned int >( durationSeconds*100.0f ) + 1u/*just beyond the animation duration*/ );
1898
1899   // We did expect the animation to finish
1900   application.SendNotification();
1901   finishCheck.CheckSignalReceived();
1902   DALI_TEST_EQUALS( actor.GetCurrentPosition(), ( targetPosition * 0.9f ), TEST_LOCATION );
1903   END_TEST;
1904 }
1905
1906 int UtcDaliAnimationSetPlayRangeN(void)
1907 {
1908   TestApplication application;
1909
1910   Actor actor = Actor::New();
1911   Stage::GetCurrent().Add(actor);
1912
1913   // Build the animation
1914   Animation animation = Animation::New(0);
1915   application.SendNotification();
1916
1917   //PlayRange out of bounds
1918   animation.SetPlayRange( Vector2(-1.0f,1.0f) );
1919   application.SendNotification();
1920   DALI_TEST_EQUALS( Vector2(0.0f,1.0f), animation.GetPlayRange(), TEST_LOCATION );
1921   animation.SetPlayRange( Vector2(0.0f,2.0f) );
1922   application.SendNotification();
1923   DALI_TEST_EQUALS( Vector2(0.0f,1.0f), animation.GetPlayRange(), TEST_LOCATION );
1924
1925   //If playRange is not in the correct order it has to be ordered
1926   animation.SetPlayRange( Vector2(0.8f,0.2f) );
1927   application.SendNotification();
1928   DALI_TEST_EQUALS( Vector2(0.2f,0.8f), animation.GetPlayRange(), TEST_LOCATION );
1929
1930   END_TEST;
1931 }
1932
1933 int UtcDaliAnimationGetPlayRangeP(void)
1934 {
1935   TestApplication application;
1936
1937   Actor actor = Actor::New();
1938   Stage::GetCurrent().Add( actor );
1939
1940   // Build the animation
1941   Animation animation = Animation::New( 1.0f );
1942   application.SendNotification();
1943
1944   //If PlayRange not specified it should be 0.0-1.0 by default
1945   DALI_TEST_EQUALS( Vector2( 0.0f,1.0f ), animation.GetPlayRange(), TEST_LOCATION );
1946
1947   // Set range between 0.4 and 0.8
1948   animation.SetPlayRange( Vector2( 0.4f, 0.8f ) );
1949   application.SendNotification();
1950   DALI_TEST_EQUALS( Vector2( 0.4f, 0.8f ), animation.GetPlayRange(), TEST_LOCATION );
1951
1952   END_TEST;
1953 }
1954
1955 int UtcDaliAnimationPlayP(void)
1956 {
1957   TestApplication application;
1958
1959   Actor actor = Actor::New();
1960   Stage::GetCurrent().Add(actor);
1961
1962   // Build the animation
1963   float durationSeconds(1.0f);
1964   Animation animation = Animation::New(durationSeconds);
1965   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
1966   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
1967
1968   // Start the animation
1969   animation.Play();
1970
1971   bool signalReceived(false);
1972   AnimationFinishCheck finishCheck(signalReceived);
1973   animation.FinishedSignal().Connect(&application, finishCheck);
1974
1975   application.SendNotification();
1976   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
1977
1978   // We didn't expect the animation to finish yet
1979   application.SendNotification();
1980   finishCheck.CheckSignalNotReceived();
1981   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
1982
1983   animation.Play(); // Test that calling play has no effect, when animation is already playing
1984   application.SendNotification();
1985   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
1986
1987   // We didn't expect the animation to finish yet
1988   application.SendNotification();
1989   finishCheck.CheckSignalNotReceived();
1990   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
1991
1992   animation.Play(); // Test that calling play has no effect, when animation is already playing
1993   application.SendNotification();
1994   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
1995
1996   // We didn't expect the animation to finish yet
1997   application.SendNotification();
1998   finishCheck.CheckSignalNotReceived();
1999   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
2000
2001   animation.Play(); // Test that calling play has no effect, when animation is already playing
2002   application.SendNotification();
2003   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
2004
2005   // We didn't expect the animation to finish yet
2006   application.SendNotification();
2007   finishCheck.CheckSignalNotReceived();
2008   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
2009
2010   animation.Play(); // Test that calling play has no effect, when animation is already playing
2011   application.SendNotification();
2012   application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
2013
2014   // We did expect the animation to finish
2015   application.SendNotification();
2016   finishCheck.CheckSignalReceived();
2017   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2018
2019   // Check that nothing has changed after a couple of buffer swaps
2020   application.Render(0);
2021   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2022   application.Render(0);
2023   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2024   END_TEST;
2025 }
2026
2027 int UtcDaliAnimationPlayOffStageP(void)
2028 {
2029   // Test that an animation can be played, when the actor is off-stage.
2030   // When the actor is added to the stage, it should appear at the current position
2031   // i.e. where it would have been anyway, if on-stage from the beginning.
2032
2033   TestApplication application;
2034
2035   Actor actor = Actor::New();
2036   Vector3 basePosition(Vector3::ZERO);
2037   DALI_TEST_EQUALS( actor.GetCurrentPosition(), basePosition, TEST_LOCATION );
2038   // Not added to the stage!
2039
2040   // Build the animation
2041   float durationSeconds(1.0f);
2042   Animation animation = Animation::New(durationSeconds);
2043   animation.SetDisconnectAction( Animation::Discard );
2044   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2045   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2046
2047   // Start the animation
2048   animation.Play();
2049
2050   bool signalReceived(false);
2051   AnimationFinishCheck finishCheck(signalReceived);
2052   animation.FinishedSignal().Connect(&application, finishCheck);
2053
2054   application.SendNotification();
2055   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
2056
2057   // We didn't expect the animation to finish yet
2058   application.SendNotification();
2059   finishCheck.CheckSignalNotReceived();
2060   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*off-stage*/, TEST_LOCATION );
2061
2062   // Add to the stage
2063   Stage::GetCurrent().Add(actor);
2064
2065   application.SendNotification();
2066   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
2067
2068   // We didn't expect the animation to finish yet
2069   application.SendNotification();
2070   finishCheck.CheckSignalNotReceived();
2071   Vector3 expectedPosition(basePosition + (targetPosition - basePosition)*0.4f);
2072   DALI_TEST_EQUALS( actor.GetCurrentPosition(), expectedPosition/*on-stage*/, TEST_LOCATION );
2073
2074   // Remove from the stage
2075   Stage::GetCurrent().Remove(actor);
2076
2077   application.SendNotification();
2078   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
2079
2080   // We didn't expect the animation to finish yet
2081   application.SendNotification();
2082   finishCheck.CheckSignalNotReceived();
2083   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*back to start position*/, TEST_LOCATION );
2084
2085   // Add to the stage
2086   Stage::GetCurrent().Add(actor);
2087
2088   application.SendNotification();
2089   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
2090
2091   // We didn't expect the animation to finish yet
2092   application.SendNotification();
2093   finishCheck.CheckSignalNotReceived();
2094   expectedPosition = Vector3(basePosition + (targetPosition - basePosition)*0.8f);
2095   DALI_TEST_EQUALS( actor.GetCurrentPosition(), expectedPosition, TEST_LOCATION );
2096
2097   application.SendNotification();
2098   application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
2099
2100   // We did expect the animation to finish
2101   application.SendNotification();
2102   finishCheck.CheckSignalReceived();
2103   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2104
2105   // Check that nothing has changed after a couple of buffer swaps
2106   application.Render(0);
2107   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2108   application.Render(0);
2109   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2110   END_TEST;
2111 }
2112
2113 int UtcDaliAnimationPlayDiscardHandleP(void)
2114 {
2115   TestApplication application;
2116
2117   Actor actor = Actor::New();
2118   Stage::GetCurrent().Add(actor);
2119
2120   // Build the animation
2121   float durationSeconds(1.0f);
2122   Animation animation = Animation::New(durationSeconds);
2123   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2124   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2125
2126   bool signalReceived(false);
2127   AnimationFinishCheck finishCheck(signalReceived);
2128   animation.FinishedSignal().Connect(&application, finishCheck);
2129
2130   // Start the animation
2131   animation.Play();
2132
2133   // This is a test of the "Fire and Forget" behaviour
2134   // Discard the animation handle!
2135   animation.Reset();
2136   DALI_TEST_CHECK( !animation );
2137
2138   application.SendNotification();
2139   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
2140
2141   // We didn't expect the animation to finish yet
2142   application.SendNotification();
2143   finishCheck.CheckSignalNotReceived();
2144   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2145
2146   application.SendNotification();
2147   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
2148
2149   // We didn't expect the animation to finish yet
2150   application.SendNotification();
2151   finishCheck.CheckSignalNotReceived();
2152   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.4f), TEST_LOCATION );
2153
2154   application.SendNotification();
2155   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
2156
2157   // We didn't expect the animation to finish yet
2158   application.SendNotification();
2159   finishCheck.CheckSignalNotReceived();
2160   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
2161
2162   application.SendNotification();
2163   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
2164
2165   // We didn't expect the animation to finish yet
2166   application.SendNotification();
2167   finishCheck.CheckSignalNotReceived();
2168   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
2169
2170   application.SendNotification();
2171   application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
2172
2173   // We did expect the animation to finish
2174   application.SendNotification();
2175   finishCheck.CheckSignalReceived();
2176   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2177
2178   // Check that nothing has changed after a couple of buffer swaps
2179   application.Render(0);
2180   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2181   application.Render(0);
2182   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2183   END_TEST;
2184 }
2185
2186 int UtcDaliAnimationPlayStopDiscardHandleP(void)
2187 {
2188   TestApplication application;
2189
2190   Actor actor = Actor::New();
2191   Stage::GetCurrent().Add(actor);
2192
2193   // Build the animation
2194   float durationSeconds(1.0f);
2195   Animation animation = Animation::New(durationSeconds);
2196   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2197   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2198
2199   // Start the animation
2200   animation.Play();
2201
2202   bool signalReceived(false);
2203   AnimationFinishCheck finishCheck(signalReceived);
2204   animation.FinishedSignal().Connect(&application, finishCheck);
2205
2206   application.SendNotification();
2207   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
2208
2209   // We didn't expect the animation to finish yet
2210   application.SendNotification();
2211   finishCheck.CheckSignalNotReceived();
2212   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2213
2214   // This is a test of the "Fire and Forget" behaviour
2215   // Stop the animation, and Discard the animation handle!
2216   animation.Stop();
2217   animation.Reset();
2218   DALI_TEST_CHECK( !animation );
2219
2220   application.SendNotification();
2221   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
2222
2223   // We expect the animation to finish at 20% progress
2224   application.SendNotification();
2225   finishCheck.CheckSignalReceived();
2226   finishCheck.Reset();
2227   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2228
2229   application.SendNotification();
2230   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
2231
2232   // Check that nothing has changed
2233   application.SendNotification();
2234   finishCheck.CheckSignalNotReceived();
2235   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2236
2237   application.SendNotification();
2238   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
2239
2240   // Check that nothing has changed
2241   application.SendNotification();
2242   finishCheck.CheckSignalNotReceived();
2243   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2244
2245   application.SendNotification();
2246   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 100% progress */);
2247
2248   // Check that nothing has changed
2249   application.SendNotification();
2250   finishCheck.CheckSignalNotReceived();
2251   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.2f), TEST_LOCATION );
2252   END_TEST;
2253 }
2254
2255 int UtcDaliAnimationPlayRangeP(void)
2256 {
2257   TestApplication application;
2258
2259   Actor actor = Actor::New();
2260   Stage::GetCurrent().Add(actor);
2261
2262   // Build the animation
2263   float durationSeconds(1.0f);
2264   Animation animation = Animation::New(durationSeconds);
2265   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2266   KeyFrames keyframes = KeyFrames::New();
2267   keyframes.Add( 0.0f , Vector3(0.0f,0.0f,0.0f ) );
2268   keyframes.Add( 1.0f , Vector3(100.0f,100.0f,100.0f ) );
2269
2270   animation.AnimateBetween( Property( actor, Actor::Property::POSITION), keyframes );
2271
2272   // Set range between 0.4 and 0.8
2273   animation.SetPlayRange( Vector2(0.4f,0.8f) );
2274   animation.Play();
2275
2276   bool signalReceived(false);
2277   AnimationFinishCheck finishCheck(signalReceived);
2278   animation.FinishedSignal().Connect(&application, finishCheck);
2279
2280   //Test that setting progress outside the range doesn't work
2281   animation.SetCurrentProgress( 0.9f );
2282   application.SendNotification();
2283   application.Render(0);
2284   DALI_TEST_EQUALS( animation.GetCurrentProgress(), 0.4f, TEST_LOCATION );
2285   animation.SetCurrentProgress( 0.2f );
2286   application.SendNotification();
2287   application.Render(0);
2288   DALI_TEST_EQUALS( animation.GetCurrentProgress(), 0.4f, TEST_LOCATION );
2289
2290   application.SendNotification();
2291   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
2292
2293   // We didn't expect the animation to finish yet
2294   application.SendNotification();
2295   finishCheck.CheckSignalNotReceived();
2296   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
2297
2298   animation.Play(); // Test that calling play has no effect, when animation is already playing
2299   application.SendNotification();
2300   application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/* 80% progress */);
2301
2302   // We did expect the animation to finish
2303   application.SendNotification();
2304   finishCheck.CheckSignalReceived();
2305   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
2306
2307   // Check that nothing has changed after a couple of buffer swaps
2308   application.Render(0);
2309   DALI_TEST_EQUALS( targetPosition * 0.8f, actor.GetCurrentPosition(), TEST_LOCATION );
2310   application.Render(0);
2311   DALI_TEST_EQUALS( targetPosition * 0.8f, actor.GetCurrentPosition(), TEST_LOCATION );
2312
2313
2314   //Loop inside the range
2315   finishCheck.Reset();
2316   animation.SetLooping( true );
2317   animation.Play();
2318   application.SendNotification();
2319   float intervalSeconds = 0.1f;
2320   float progress = 0.4f;
2321   for (int iterations = 0; iterations < 10; ++iterations )
2322   {
2323     application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
2324
2325     progress += intervalSeconds;
2326     if (progress > 0.8f)
2327     {
2328       progress = progress - 0.4f;
2329     }
2330
2331     DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentPosition(), 0.001f, TEST_LOCATION );
2332   }
2333
2334   // We didn't expect the animation to finish yet
2335   application.SendNotification();
2336   finishCheck.CheckSignalNotReceived();
2337
2338
2339   //Test change range on the fly
2340   animation.SetPlayRange( Vector2( 0.2f, 0.9f ) );
2341   application.SendNotification();
2342
2343   for (int iterations = 0; iterations < 10; ++iterations )
2344   {
2345     application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
2346
2347     progress += intervalSeconds;
2348     if (progress > 0.9f)
2349     {
2350       progress = progress - 0.7f;
2351     }
2352
2353     DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentPosition(), 0.001f, TEST_LOCATION );
2354   }
2355
2356   END_TEST;
2357 }
2358
2359 int UtcDaliAnimationPlayFromP(void)
2360 {
2361   TestApplication application;
2362
2363   Actor actor = Actor::New();
2364   Stage::GetCurrent().Add(actor);
2365
2366   // Build the animation
2367   float durationSeconds(1.0f);
2368   Animation animation = Animation::New(durationSeconds);
2369   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2370   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2371
2372   // Start the animation from 40% progress
2373   animation.PlayFrom( 0.4f );
2374
2375   bool signalReceived(false);
2376   AnimationFinishCheck finishCheck(signalReceived);
2377   animation.FinishedSignal().Connect(&application, finishCheck);
2378
2379   application.SendNotification();
2380   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
2381
2382   // We didn't expect the animation to finish yet
2383   application.SendNotification();
2384   finishCheck.CheckSignalNotReceived();
2385   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.6f), TEST_LOCATION );
2386
2387   animation.Play(); // Test that calling play has no effect, when animation is already playing
2388   application.SendNotification();
2389   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
2390
2391   // We didn't expect the animation to finish yet
2392   application.SendNotification();
2393   finishCheck.CheckSignalNotReceived();
2394   DALI_TEST_EQUALS( actor.GetCurrentPosition(), (targetPosition * 0.8f), TEST_LOCATION );
2395
2396   application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
2397   // We did expect the animation to finish
2398   application.SendNotification();
2399   finishCheck.CheckSignalReceived();
2400   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2401
2402   // Check that nothing has changed after a couple of buffer swaps
2403   application.Render(0);
2404   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2405   application.Render(0);
2406   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2407   END_TEST;
2408 }
2409
2410 int UtcDaliAnimationPlayFromN(void)
2411 {
2412   TestApplication application;
2413
2414   Actor actor = Actor::New();
2415   Stage::GetCurrent().Add(actor);
2416
2417   // Build the animation
2418   float durationSeconds(1.0f);
2419   Animation animation = Animation::New(durationSeconds);
2420   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2421   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2422
2423   //PlayFrom with an argument outside the range [0..1] will be ignored
2424   animation.PlayFrom(-1.0f);
2425   application.SendNotification();
2426   DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
2427
2428   animation.PlayFrom(100.0f);
2429   application.SendNotification();
2430   DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
2431   END_TEST;
2432 }
2433
2434 int UtcDaliAnimationPauseP(void)
2435 {
2436   TestApplication application;
2437
2438   Actor actor = Actor::New();
2439   Stage::GetCurrent().Add(actor);
2440
2441   // Build the animation
2442   float durationSeconds(1.0f);
2443   Animation animation = Animation::New(durationSeconds);
2444   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2445   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2446
2447   Vector3 fiftyPercentProgress(targetPosition * 0.5f);
2448
2449   // Start the animation
2450   animation.Play();
2451
2452   bool signalReceived(false);
2453   AnimationFinishCheck finishCheck(signalReceived);
2454   animation.FinishedSignal().Connect(&application, finishCheck);
2455
2456   application.SendNotification();
2457   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2458
2459   // We didn't expect the animation to finish yet
2460   application.SendNotification();
2461   finishCheck.CheckSignalNotReceived();
2462   DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
2463
2464   // Pause the animation
2465   animation.Pause();
2466   application.SendNotification();
2467
2468   // Loop 5 times
2469   for (int i=0; i<5; ++i)
2470   {
2471     application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
2472
2473     // We didn't expect the animation to finish yet
2474     application.SendNotification();
2475     finishCheck.CheckSignalNotReceived();
2476     DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress/* Still 50% progress when paused */, TEST_LOCATION );
2477   }
2478
2479   // Keep going
2480   animation.Play();
2481   application.SendNotification();
2482   application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
2483
2484   // We didn't expect the animation to finish yet
2485   application.SendNotification();
2486   finishCheck.CheckSignalNotReceived();
2487
2488   application.SendNotification();
2489   application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
2490
2491   // We did expect the animation to finish
2492   application.SendNotification();
2493   finishCheck.CheckSignalReceived();
2494   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2495
2496   // Check that nothing has changed after a couple of buffer swaps
2497   application.Render(0);
2498   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2499   application.Render(0);
2500   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2501   END_TEST;
2502 }
2503
2504
2505 int UtcDaliAnimationGetStateP(void)
2506 {
2507   TestApplication application;
2508
2509   Actor actor = Actor::New();
2510   Stage::GetCurrent().Add(actor);
2511
2512   // Build the animation
2513   float durationSeconds(1.0f);
2514   Animation animation = Animation::New(durationSeconds);
2515   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2516   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2517   DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
2518
2519   Vector3 fiftyPercentProgress(targetPosition * 0.5f);
2520
2521   // Start the animation
2522   animation.Play();
2523
2524   DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2525
2526   bool signalReceived(false);
2527   AnimationFinishCheck finishCheck(signalReceived);
2528   animation.FinishedSignal().Connect(&application, finishCheck);
2529
2530   application.SendNotification();
2531   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2532
2533   // We didn't expect the animation to finish yet
2534   application.SendNotification();
2535   finishCheck.CheckSignalNotReceived();
2536   DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2537   DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
2538
2539   // Pause the animation
2540   animation.Pause();
2541   DALI_TEST_EQUALS( animation.GetState(), Animation::PAUSED, TEST_LOCATION );
2542   application.SendNotification();
2543   application.Render(0.f);
2544
2545   // Loop 5 times
2546   for (int i=0; i<5; ++i)
2547   {
2548     application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
2549
2550     // We didn't expect the animation to finish yet
2551     application.SendNotification();
2552     finishCheck.CheckSignalNotReceived();
2553     DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress/* Still 50% progress when paused */, TEST_LOCATION );
2554     DALI_TEST_EQUALS( animation.GetState(), Animation::PAUSED, TEST_LOCATION );
2555   }
2556
2557   // Keep going
2558   finishCheck.Reset();
2559   animation.Play();
2560   DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2561   application.SendNotification();
2562   application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
2563   // We didn't expect the animation to finish yet
2564   application.SendNotification();
2565   finishCheck.CheckSignalNotReceived();
2566   DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2567
2568   application.SendNotification();
2569   application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
2570
2571   // We did expect the animation to finish
2572   application.SendNotification();
2573   finishCheck.CheckSignalReceived();
2574   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
2575   DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
2576
2577   // Check that nothing has changed after a couple of buffer swaps
2578   application.Render(0);
2579   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2580   application.Render(0);
2581   DALI_TEST_EQUALS( targetPosition, actor.GetCurrentPosition(), TEST_LOCATION );
2582   DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
2583
2584   // re-play
2585   finishCheck.Reset();
2586   animation.Play();
2587   DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2588   application.SendNotification();
2589   application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
2590   application.SendNotification();
2591   finishCheck.CheckSignalNotReceived();
2592   DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
2593
2594
2595   END_TEST;
2596 }
2597
2598 int UtcDaliAnimationStopP(void)
2599 {
2600   TestApplication application;
2601
2602   Actor actor = Actor::New();
2603   Stage::GetCurrent().Add(actor);
2604
2605   // Build the animation
2606   float durationSeconds(1.0f);
2607   Animation animation = Animation::New(durationSeconds);
2608   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2609   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2610
2611   Vector3 fiftyPercentProgress(targetPosition * 0.5f);
2612
2613   // Start the animation
2614   animation.Play();
2615
2616   bool signalReceived(false);
2617   AnimationFinishCheck finishCheck(signalReceived);
2618   animation.FinishedSignal().Connect(&application, finishCheck);
2619
2620   application.SendNotification();
2621   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2622
2623   // We didn't expect the animation to finish yet
2624   application.SendNotification();
2625   finishCheck.CheckSignalNotReceived();
2626   DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
2627
2628   // Stop the animation
2629   animation.Stop();
2630   application.SendNotification();
2631
2632   // Loop 5 times
2633   for (int i=0; i<5; ++i)
2634   {
2635     application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
2636
2637     // We did expect the animation to finish
2638     application.SendNotification();
2639     finishCheck.CheckSignalReceived();
2640     DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress/* Still 50% progress when stopped */, TEST_LOCATION );
2641   }
2642   END_TEST;
2643 }
2644
2645 int UtcDaliAnimationStopSetPositionP(void)
2646 {
2647   // Test that Animation::Stop & Actor::SetPosition can be used in conjunction
2648   // i.e. to check that the animation does not interfere with the position set.
2649
2650   TestApplication application;
2651
2652   Actor actor = Actor::New();
2653   Stage::GetCurrent().Add(actor);
2654
2655   // Build the animation
2656   float durationSeconds(1.0f);
2657   Animation animation = Animation::New(durationSeconds);
2658   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2659   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2660
2661   Vector3 fiftyPercentProgress(targetPosition * 0.5f);
2662
2663   // Start the animation
2664   animation.Play();
2665
2666   bool signalReceived(false);
2667   AnimationFinishCheck finishCheck(signalReceived);
2668   animation.FinishedSignal().Connect(&application, finishCheck);
2669
2670   application.SendNotification();
2671   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2672
2673   // We didn't expect the animation to finish yet
2674   application.SendNotification();
2675   finishCheck.CheckSignalNotReceived();
2676   DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
2677
2678   // Stop the animation
2679   animation.Stop();
2680   Vector3 positionSet(2.0f, 3.0f, 4.0f);
2681   actor.SetPosition(positionSet);
2682   application.SendNotification();
2683
2684   // Loop 5 times
2685   for (int i=0; i<5; ++i)
2686   {
2687     application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
2688
2689     // We did expect the animation to finish
2690     application.SendNotification();
2691     finishCheck.CheckSignalReceived();
2692     DALI_TEST_EQUALS( actor.GetCurrentPosition(), positionSet/*Animation should not interfere with this*/, TEST_LOCATION );
2693   }
2694   END_TEST;
2695 }
2696
2697 int UtcDaliAnimationClearP(void)
2698 {
2699   TestApplication application;
2700
2701   Actor actor = Actor::New();
2702   Stage::GetCurrent().Add(actor);
2703
2704   // Build the animation
2705   float durationSeconds(1.0f);
2706   Animation animation = Animation::New(durationSeconds);
2707   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
2708   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
2709
2710   Vector3 fiftyPercentProgress(targetPosition * 0.5f);
2711
2712   // Start the animation
2713   animation.Play();
2714
2715   bool signalReceived(false);
2716   AnimationFinishCheck finishCheck(signalReceived);
2717   animation.FinishedSignal().Connect(&application, finishCheck);
2718
2719   application.SendNotification();
2720   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2721
2722   // We didn't expect the animation to finish yet
2723   application.SendNotification();
2724   finishCheck.CheckSignalNotReceived();
2725   DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress, TEST_LOCATION );
2726
2727   // Clear the animation
2728   animation.Clear();
2729   application.SendNotification();
2730
2731   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
2732
2733   // We don't expect the animation to finish now
2734   application.SendNotification();
2735   finishCheck.CheckSignalNotReceived();
2736   DALI_TEST_EQUALS( actor.GetCurrentPosition(), fiftyPercentProgress/* Still 50% progress since the animator was destroyed */, TEST_LOCATION );
2737
2738   // Restart as a scale animation; this should not move the actor's position
2739   finishCheck.Reset();
2740   actor.SetPosition(Vector3::ZERO);
2741   Vector3 targetScale(3.0f, 3.0f, 3.0f);
2742   animation.AnimateTo( Property( actor, Actor::Property::SCALE ), targetScale, AlphaFunction::LINEAR );
2743   animation.Play();
2744
2745   application.SendNotification();
2746   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
2747
2748   // We didn't expect the animation to finish yet
2749   application.SendNotification();
2750   finishCheck.CheckSignalNotReceived();
2751   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*Check move-animator was destroyed*/, TEST_LOCATION );
2752   DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3(2.0f, 2.0f, 2.0f), TEST_LOCATION );
2753
2754   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
2755
2756   // We did expect the animation to finish
2757   application.SendNotification();
2758   finishCheck.CheckSignalReceived();
2759   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO/*Check move-animator was destroyed*/, TEST_LOCATION );
2760   DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
2761   END_TEST;
2762 }
2763
2764 int UtcDaliAnimationFinishedSignalP(void)
2765 {
2766   TestApplication application;
2767
2768   // Start the empty animation
2769   float durationSeconds(1.0f);
2770   Animation animation = Animation::New(durationSeconds);
2771   animation.Play();
2772
2773   bool signalReceived(false);
2774   AnimationFinishCheck finishCheck(signalReceived);
2775   animation.FinishedSignal().Connect(&application, finishCheck);
2776
2777   application.SendNotification();
2778   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*beyond the animation duration*/);
2779
2780   // We did expect the animation to finish
2781   application.SendNotification();
2782   finishCheck.CheckSignalReceived();
2783   END_TEST;
2784 }
2785
2786 int UtcDaliAnimationAnimateByBooleanP(void)
2787 {
2788   TestApplication application;
2789
2790   Actor actor = Actor::New();
2791
2792   // Register a boolean property
2793   bool startValue(false);
2794   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
2795   Stage::GetCurrent().Add(actor);
2796   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
2797   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2798
2799   // Build the animation
2800   float durationSeconds(2.0f);
2801   Animation animation = Animation::New(durationSeconds);
2802   const bool relativeValue(true);
2803   const bool finalValue( false || relativeValue );
2804   animation.AnimateBy(Property(actor, index), relativeValue);
2805
2806   // Start the animation
2807   animation.Play();
2808
2809   bool signalReceived(false);
2810   AnimationFinishCheck finishCheck(signalReceived);
2811   animation.FinishedSignal().Connect(&application, finishCheck);
2812
2813   application.SendNotification();
2814   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
2815
2816   // We didn't expect the animation to finish yet
2817   application.SendNotification();
2818   finishCheck.CheckSignalNotReceived();
2819   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2820
2821   application.SendNotification();
2822   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
2823
2824   // We did expect the animation to finish
2825   application.SendNotification();
2826   finishCheck.CheckSignalReceived();
2827   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2828
2829   // Check that nothing has changed after a couple of buffer swaps
2830   application.Render(0);
2831   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2832   application.Render(0);
2833   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2834
2835   // Repeat with relative value "false" - this should be an NOOP
2836   animation = Animation::New(durationSeconds);
2837   bool noOpValue(false);
2838   animation.AnimateBy(Property(actor, index), noOpValue);
2839
2840   // Start the animation
2841   animation.Play();
2842
2843   finishCheck.Reset();
2844   animation.FinishedSignal().Connect(&application, finishCheck);
2845
2846   application.SendNotification();
2847   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
2848
2849   // We didn't expect the animation to finish yet
2850   application.SendNotification();
2851   finishCheck.CheckSignalNotReceived();
2852   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2853
2854   application.SendNotification();
2855   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
2856
2857   // We did expect the animation to finish
2858   application.SendNotification();
2859   finishCheck.CheckSignalReceived();
2860   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2861
2862   // Check that nothing has changed after a couple of buffer swaps
2863   application.Render(0);
2864   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2865   application.Render(0);
2866   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2867   END_TEST;
2868 }
2869
2870 int UtcDaliAnimationAnimateByBooleanAlphaFunctionP(void)
2871 {
2872   TestApplication application;
2873
2874   Actor actor = Actor::New();
2875
2876   // Register a boolean property
2877   bool startValue(false);
2878   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
2879   Stage::GetCurrent().Add(actor);
2880   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
2881   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2882
2883   // Build the animation
2884   float durationSeconds(2.0f);
2885   Animation animation = Animation::New(durationSeconds);
2886   bool relativeValue(true);
2887   bool finalValue( false || relativeValue );
2888   animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_IN);
2889
2890   // Start the animation
2891   animation.Play();
2892
2893   bool signalReceived(false);
2894   AnimationFinishCheck finishCheck(signalReceived);
2895   animation.FinishedSignal().Connect(&application, finishCheck);
2896
2897   application.SendNotification();
2898   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
2899
2900   // We didn't expect the animation to finish yet
2901   application.SendNotification();
2902   finishCheck.CheckSignalNotReceived();
2903   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2904
2905   application.SendNotification();
2906   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
2907
2908   // We did expect the animation to finish
2909   application.SendNotification();
2910   finishCheck.CheckSignalReceived();
2911   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2912
2913   // Check that nothing has changed after a couple of buffer swaps
2914   application.Render(0);
2915   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2916   application.Render(0);
2917   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2918
2919   // Repeat with relative value "false" - this should be an NOOP
2920   animation = Animation::New(durationSeconds);
2921   bool noOpValue(false);
2922   animation.AnimateBy(Property(actor, index), noOpValue, AlphaFunction::EASE_IN);
2923
2924   // Start the animation
2925   animation.Play();
2926
2927   finishCheck.Reset();
2928   animation.FinishedSignal().Connect(&application, finishCheck);
2929
2930   application.SendNotification();
2931   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
2932
2933   // We didn't expect the animation to finish yet
2934   application.SendNotification();
2935   finishCheck.CheckSignalNotReceived();
2936   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2937
2938   application.SendNotification();
2939   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
2940
2941   // We did expect the animation to finish
2942   application.SendNotification();
2943   finishCheck.CheckSignalReceived();
2944   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2945   END_TEST;
2946 }
2947
2948 int UtcDaliAnimationAnimateByBooleanTimePeriodP(void)
2949 {
2950   TestApplication application;
2951
2952   Actor actor = Actor::New();
2953
2954   // Register a boolean property
2955   bool startValue(false);
2956   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
2957   Stage::GetCurrent().Add(actor);
2958   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
2959   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2960
2961   // Build the animation
2962   float durationSeconds(2.0f);
2963   Animation animation = Animation::New(durationSeconds);
2964   bool relativeValue(true);
2965   bool finalValue( false || relativeValue );
2966   float animatorDurationSeconds(durationSeconds * 0.5f);
2967   animation.AnimateBy( Property(actor, index),
2968                        relativeValue,
2969                        TimePeriod( animatorDurationSeconds ) );
2970
2971   // Start the animation
2972   animation.Play();
2973
2974   bool signalReceived(false);
2975   AnimationFinishCheck finishCheck(signalReceived);
2976   animation.FinishedSignal().Connect(&application, finishCheck);
2977
2978   application.SendNotification();
2979   application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
2980
2981   // We didn't expect the animation to finish yet
2982   application.SendNotification();
2983   finishCheck.CheckSignalNotReceived();
2984   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
2985
2986   application.SendNotification();
2987   application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
2988
2989   // We didn't expect the animation to finish yet...
2990   application.SendNotification();
2991   finishCheck.CheckSignalNotReceived();
2992
2993   // ...however we should have reached the final value
2994   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
2995
2996   application.SendNotification();
2997   application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
2998
2999   // We did expect the animation to finish
3000   application.SendNotification();
3001   finishCheck.CheckSignalReceived();
3002   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3003
3004   // Check that nothing has changed after a couple of buffer swaps
3005   application.Render(0);
3006   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3007   application.Render(0);
3008   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3009   END_TEST;
3010 }
3011
3012 int UtcDaliAnimationAnimateByBooleanAlphaFunctionTimePeriodP(void)
3013 {
3014   TestApplication application;
3015
3016   Actor actor = Actor::New();
3017
3018   // Register a boolean property
3019   bool startValue(false);
3020   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3021   Stage::GetCurrent().Add(actor);
3022   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
3023   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
3024
3025   // Build the animation
3026   float durationSeconds(2.0f);
3027   Animation animation = Animation::New(durationSeconds);
3028   bool relativeValue(true);
3029   bool finalValue( false || relativeValue );
3030   float animatorDurationSeconds(durationSeconds * 0.5f);
3031   animation.AnimateBy( Property(actor, index),
3032                        relativeValue,
3033                        AlphaFunction::EASE_IN_OUT,
3034                        TimePeriod( animatorDurationSeconds ) );
3035
3036   // Start the animation
3037   animation.Play();
3038
3039   bool signalReceived(false);
3040   AnimationFinishCheck finishCheck(signalReceived);
3041   animation.FinishedSignal().Connect(&application, finishCheck);
3042
3043   application.SendNotification();
3044   application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
3045
3046   // We didn't expect the animation to finish yet
3047   application.SendNotification();
3048   finishCheck.CheckSignalNotReceived();
3049   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
3050
3051   application.SendNotification();
3052   application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
3053
3054   // We didn't expect the animation to finish yet...
3055   application.SendNotification();
3056   finishCheck.CheckSignalNotReceived();
3057
3058   // ...however we should have reached the final value
3059   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3060
3061   application.SendNotification();
3062   application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
3063
3064   // We did expect the animation to finish
3065   application.SendNotification();
3066   finishCheck.CheckSignalReceived();
3067   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3068
3069   // Check that nothing has changed after a couple of buffer swaps
3070   application.Render(0);
3071   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3072   application.Render(0);
3073   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
3074   END_TEST;
3075 }
3076
3077 int UtcDaliAnimationAnimateByFloatP(void)
3078 {
3079   TestApplication application;
3080
3081   Actor actor = Actor::New();
3082
3083   // Register a float property
3084   float startValue(10.0f);
3085   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3086   Stage::GetCurrent().Add(actor);
3087   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
3088   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3089
3090   // Build the animation
3091   float durationSeconds(2.0f);
3092   Animation animation = Animation::New(durationSeconds);
3093   float targetValue(50.0f);
3094   float relativeValue(targetValue - startValue);
3095   animation.AnimateBy(Property(actor, index), relativeValue);
3096
3097   float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3098
3099   // Start the animation
3100   animation.Play();
3101
3102   bool signalReceived(false);
3103   AnimationFinishCheck finishCheck(signalReceived);
3104   animation.FinishedSignal().Connect(&application, finishCheck);
3105
3106   application.SendNotification();
3107   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3108
3109   // We didn't expect the animation to finish yet
3110   application.SendNotification();
3111   finishCheck.CheckSignalNotReceived();
3112   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
3113
3114   application.SendNotification();
3115   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3116
3117   // We did expect the animation to finish
3118   application.SendNotification();
3119   finishCheck.CheckSignalReceived();
3120   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3121
3122   // Check that nothing has changed after a couple of buffer swaps
3123   application.Render(0);
3124   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3125   application.Render(0);
3126   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3127   END_TEST;
3128 }
3129
3130 int UtcDaliAnimationAnimateByFloatAlphaFunctionP(void)
3131 {
3132   TestApplication application;
3133
3134   Actor actor = Actor::New();
3135
3136   // Register a float property
3137   float startValue(10.0f);
3138   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3139   Stage::GetCurrent().Add(actor);
3140   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
3141   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3142
3143   // Build the animation
3144   float durationSeconds(1.0f);
3145   Animation animation = Animation::New(durationSeconds);
3146   float targetValue(90.0f);
3147   float relativeValue(targetValue - startValue);
3148   animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
3149
3150   float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3151
3152   // Start the animation
3153   animation.Play();
3154
3155   bool signalReceived(false);
3156   AnimationFinishCheck finishCheck(signalReceived);
3157   animation.FinishedSignal().Connect(&application, finishCheck);
3158
3159   application.SendNotification();
3160   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3161
3162   // We didn't expect the animation to finish yet
3163   application.SendNotification();
3164   finishCheck.CheckSignalNotReceived();
3165
3166   // The position should have moved more, than with a linear alpha function
3167   float current( DevelHandle::GetCurrentProperty< float >( actor, index ) );
3168   DALI_TEST_CHECK( current > ninetyFivePercentProgress );
3169
3170   application.SendNotification();
3171   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3172
3173   // We did expect the animation to finish
3174   application.SendNotification();
3175   finishCheck.CheckSignalReceived();
3176   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3177
3178   // Check that nothing has changed after a couple of buffer swaps
3179   application.Render(0);
3180   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3181   application.Render(0);
3182   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3183   END_TEST;
3184 }
3185
3186 int UtcDaliAnimationAnimateByFloatTimePeriodP(void)
3187 {
3188   TestApplication application;
3189
3190   Actor actor = Actor::New();
3191
3192   // Register a float property
3193   float startValue(10.0f);
3194   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3195   Stage::GetCurrent().Add(actor);
3196   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
3197   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3198
3199   // Build the animation
3200   float durationSeconds(1.0f);
3201   Animation animation = Animation::New(durationSeconds);
3202   float targetValue(30.0f);
3203   float relativeValue(targetValue - startValue);
3204   float delay = 0.5f;
3205   animation.AnimateBy(Property(actor, index),
3206                       relativeValue,
3207                       TimePeriod(delay, durationSeconds - delay));
3208
3209   // Start the animation
3210   animation.Play();
3211
3212   bool signalReceived(false);
3213   AnimationFinishCheck finishCheck(signalReceived);
3214   animation.FinishedSignal().Connect(&application, finishCheck);
3215
3216   application.SendNotification();
3217   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3218
3219   // We didn't expect the animation to finish yet
3220   application.SendNotification();
3221   finishCheck.CheckSignalNotReceived();
3222   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3223
3224   application.SendNotification();
3225   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3226
3227   // We didn't expect the animation to finish yet
3228   application.SendNotification();
3229   finishCheck.CheckSignalNotReceived();
3230   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3231
3232   application.SendNotification();
3233   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3234
3235   // We did expect the animation to finish
3236   application.SendNotification();
3237   finishCheck.CheckSignalReceived();
3238   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3239
3240   // Check that nothing has changed after a couple of buffer swaps
3241   application.Render(0);
3242   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3243   application.Render(0);
3244   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3245   END_TEST;
3246 }
3247
3248 int UtcDaliAnimationAnimateByFloatAlphaFunctionTimePeriodP(void)
3249 {
3250   TestApplication application;
3251
3252   Actor actor = Actor::New();
3253
3254   // Register a float property
3255   float startValue(10.0f);
3256   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3257   Stage::GetCurrent().Add(actor);
3258   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
3259   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3260
3261   // Build the animation
3262   float durationSeconds(1.0f);
3263   Animation animation = Animation::New(durationSeconds);
3264   float targetValue(30.0f);
3265   float relativeValue(targetValue - startValue);
3266   float delay = 0.5f;
3267   animation.AnimateBy(Property(actor, index),
3268                       relativeValue,
3269                       AlphaFunction::LINEAR,
3270                       TimePeriod(delay, durationSeconds - delay));
3271
3272   // Start the animation
3273   animation.Play();
3274
3275   bool signalReceived(false);
3276   AnimationFinishCheck finishCheck(signalReceived);
3277   animation.FinishedSignal().Connect(&application, finishCheck);
3278
3279   application.SendNotification();
3280   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3281
3282   // We didn't expect the animation to finish yet
3283   application.SendNotification();
3284   finishCheck.CheckSignalNotReceived();
3285   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
3286
3287   application.SendNotification();
3288   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3289
3290   // We didn't expect the animation to finish yet
3291   application.SendNotification();
3292   finishCheck.CheckSignalNotReceived();
3293   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3294
3295   application.SendNotification();
3296   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3297
3298   // We did expect the animation to finish
3299   application.SendNotification();
3300   finishCheck.CheckSignalReceived();
3301   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3302
3303   // Check that nothing has changed after a couple of buffer swaps
3304   application.Render(0);
3305   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3306   application.Render(0);
3307   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
3308   END_TEST;
3309 }
3310
3311 int UtcDaliAnimationAnimateByIntegerP(void)
3312 {
3313   TestApplication application;
3314
3315   Actor actor = Actor::New();
3316
3317   // Register an integer property
3318   int startValue(1);
3319   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3320   Stage::GetCurrent().Add(actor);
3321   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
3322   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3323
3324   // Build the animation
3325   float durationSeconds(2.0f);
3326   Animation animation = Animation::New(durationSeconds);
3327   int targetValue(50);
3328   int relativeValue(targetValue - startValue);
3329   animation.AnimateBy(Property(actor, index), relativeValue);
3330
3331   int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
3332
3333   // Start the animation
3334   animation.Play();
3335
3336   bool signalReceived(false);
3337   AnimationFinishCheck finishCheck(signalReceived);
3338   animation.FinishedSignal().Connect(&application, finishCheck);
3339
3340   application.SendNotification();
3341   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3342
3343   // We didn't expect the animation to finish yet
3344   application.SendNotification();
3345   finishCheck.CheckSignalNotReceived();
3346   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
3347
3348   application.SendNotification();
3349   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3350
3351   // We did expect the animation to finish
3352   application.SendNotification();
3353   finishCheck.CheckSignalReceived();
3354   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3355
3356   // Check that nothing has changed after a couple of buffer swaps
3357   application.Render(0);
3358   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3359   application.Render(0);
3360   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3361   END_TEST;
3362 }
3363
3364 int UtcDaliAnimationAnimateByIntegerAlphaFunctionP(void)
3365 {
3366   TestApplication application;
3367
3368   Actor actor = Actor::New();
3369
3370   // Register an integer property
3371   int startValue(1);
3372   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3373   Stage::GetCurrent().Add(actor);
3374   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
3375   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3376
3377   // Build the animation
3378   float durationSeconds(1.0f);
3379   Animation animation = Animation::New(durationSeconds);
3380   int targetValue(90);
3381   int relativeValue(targetValue - startValue);
3382   animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
3383
3384   int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
3385
3386   // Start the animation
3387   animation.Play();
3388
3389   bool signalReceived(false);
3390   AnimationFinishCheck finishCheck(signalReceived);
3391   animation.FinishedSignal().Connect(&application, finishCheck);
3392
3393   application.SendNotification();
3394   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3395
3396   // We didn't expect the animation to finish yet
3397   application.SendNotification();
3398   finishCheck.CheckSignalNotReceived();
3399
3400   // The position should have moved more, than with a linear alpha function
3401   int current( DevelHandle::GetCurrentProperty< int >( actor, index ) );
3402   DALI_TEST_CHECK( current > ninetyFivePercentProgress );
3403
3404   application.SendNotification();
3405   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3406
3407   // We did expect the animation to finish
3408   application.SendNotification();
3409   finishCheck.CheckSignalReceived();
3410   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3411
3412   // Check that nothing has changed after a couple of buffer swaps
3413   application.Render(0);
3414   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3415   application.Render(0);
3416   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3417   END_TEST;
3418 }
3419
3420 int UtcDaliAnimationAnimateByIntegerTimePeriodP(void)
3421 {
3422   TestApplication application;
3423
3424   Actor actor = Actor::New();
3425
3426   // Register an integer property
3427   int startValue(10);
3428   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3429   Stage::GetCurrent().Add(actor);
3430   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
3431   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3432
3433   // Build the animation
3434   float durationSeconds(1.0f);
3435   Animation animation = Animation::New(durationSeconds);
3436   int targetValue(30);
3437   int relativeValue(targetValue - startValue);
3438   float delay = 0.5f;
3439   animation.AnimateBy(Property(actor, index),
3440                       relativeValue,
3441                       TimePeriod(delay, durationSeconds - delay));
3442
3443   // Start the animation
3444   animation.Play();
3445
3446   bool signalReceived(false);
3447   AnimationFinishCheck finishCheck(signalReceived);
3448   animation.FinishedSignal().Connect(&application, finishCheck);
3449
3450   application.SendNotification();
3451   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3452
3453   // We didn't expect the animation to finish yet
3454   application.SendNotification();
3455   finishCheck.CheckSignalNotReceived();
3456   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3457
3458   application.SendNotification();
3459   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3460
3461   // We didn't expect the animation to finish yet
3462   application.SendNotification();
3463   finishCheck.CheckSignalNotReceived();
3464   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
3465
3466   application.SendNotification();
3467   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3468
3469   // We did expect the animation to finish
3470   application.SendNotification();
3471   finishCheck.CheckSignalReceived();
3472   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3473
3474   // Check that nothing has changed after a couple of buffer swaps
3475   application.Render(0);
3476   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3477   application.Render(0);
3478   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3479   END_TEST;
3480 }
3481
3482 int UtcDaliAnimationAnimateByIntegerAlphaFunctionTimePeriodP(void)
3483 {
3484   TestApplication application;
3485
3486   Actor actor = Actor::New();
3487
3488   // Register an integer property
3489   int startValue(10);
3490   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3491   Stage::GetCurrent().Add(actor);
3492   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
3493   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3494
3495   // Build the animation
3496   float durationSeconds(1.0f);
3497   Animation animation = Animation::New(durationSeconds);
3498   int targetValue(30);
3499   int relativeValue(targetValue - startValue);
3500   float delay = 0.5f;
3501   animation.AnimateBy(Property(actor, index),
3502                       relativeValue,
3503                       AlphaFunction::LINEAR,
3504                       TimePeriod(delay, durationSeconds - delay));
3505
3506   // Start the animation
3507   animation.Play();
3508
3509   bool signalReceived(false);
3510   AnimationFinishCheck finishCheck(signalReceived);
3511   animation.FinishedSignal().Connect(&application, finishCheck);
3512
3513   application.SendNotification();
3514   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3515
3516   // We didn't expect the animation to finish yet
3517   application.SendNotification();
3518   finishCheck.CheckSignalNotReceived();
3519   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
3520
3521   application.SendNotification();
3522   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3523
3524   // We didn't expect the animation to finish yet
3525   application.SendNotification();
3526   finishCheck.CheckSignalNotReceived();
3527   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
3528
3529   application.SendNotification();
3530   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3531
3532   // We did expect the animation to finish
3533   application.SendNotification();
3534   finishCheck.CheckSignalReceived();
3535   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3536
3537   // Check that nothing has changed after a couple of buffer swaps
3538   application.Render(0);
3539   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3540   application.Render(0);
3541   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
3542   END_TEST;
3543 }
3544
3545 int UtcDaliAnimationAnimateByVector2P(void)
3546 {
3547   TestApplication application;
3548
3549   Actor actor = Actor::New();
3550
3551   // Register a Vector2 property
3552   Vector2 startValue(10.0f, 10.0f);
3553   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3554   Stage::GetCurrent().Add(actor);
3555   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
3556   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3557
3558   // Build the animation
3559   float durationSeconds(2.0f);
3560   Animation animation = Animation::New(durationSeconds);
3561   Vector2 targetValue(60.0f, 60.0f);
3562   Vector2 relativeValue(targetValue - startValue);
3563   animation.AnimateBy(Property(actor, index), relativeValue);
3564
3565   Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3566
3567   // Start the animation
3568   animation.Play();
3569
3570   bool signalReceived(false);
3571   AnimationFinishCheck finishCheck(signalReceived);
3572   animation.FinishedSignal().Connect(&application, finishCheck);
3573
3574   application.SendNotification();
3575   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3576
3577   // We didn't expect the animation to finish yet
3578   application.SendNotification();
3579   finishCheck.CheckSignalNotReceived();
3580   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
3581
3582   application.SendNotification();
3583   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3584
3585   // We did expect the animation to finish
3586   application.SendNotification();
3587   finishCheck.CheckSignalReceived();
3588   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3589
3590   // Check that nothing has changed after a couple of buffer swaps
3591   application.Render(0);
3592   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3593   application.Render(0);
3594   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3595   END_TEST;
3596 }
3597
3598 int UtcDaliAnimationAnimateByVector2AlphaFunctionP(void)
3599 {
3600   TestApplication application;
3601
3602   Actor actor = Actor::New();
3603
3604   // Register a Vector2 property
3605   Vector2 startValue(100.0f, 100.0f);
3606   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3607   Stage::GetCurrent().Add(actor);
3608   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
3609   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3610
3611   // Build the animation
3612   float durationSeconds(1.0f);
3613   Animation animation = Animation::New(durationSeconds);
3614   Vector2 targetValue(20.0f, 20.0f);
3615   Vector2 relativeValue(targetValue - startValue);
3616   animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
3617
3618   Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3619
3620   // Start the animation
3621   animation.Play();
3622
3623   bool signalReceived(false);
3624   AnimationFinishCheck finishCheck(signalReceived);
3625   animation.FinishedSignal().Connect(&application, finishCheck);
3626
3627   application.SendNotification();
3628   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3629
3630   // We didn't expect the animation to finish yet
3631   application.SendNotification();
3632   finishCheck.CheckSignalNotReceived();
3633
3634   // The position should have moved more, than with a linear alpha function
3635   Vector2 current( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ) );
3636   DALI_TEST_CHECK( current.x < ninetyFivePercentProgress.x );
3637   DALI_TEST_CHECK( current.y < ninetyFivePercentProgress.y );
3638
3639   application.SendNotification();
3640   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3641
3642   // We did expect the animation to finish
3643   application.SendNotification();
3644   finishCheck.CheckSignalReceived();
3645   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3646
3647   // Check that nothing has changed after a couple of buffer swaps
3648   application.Render(0);
3649   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3650   application.Render(0);
3651   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3652   END_TEST;
3653 }
3654
3655 int UtcDaliAnimationAnimateByVector2TimePeriodP(void)
3656 {
3657   TestApplication application;
3658
3659   Actor actor = Actor::New();
3660
3661   // Register a Vector2 property
3662   Vector2 startValue(10.0f, 10.0f);
3663   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3664   Stage::GetCurrent().Add(actor);
3665   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
3666   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3667
3668   // Build the animation
3669   float durationSeconds(1.0f);
3670   Animation animation = Animation::New(durationSeconds);
3671   Vector2 targetValue(30.0f, 30.0f);
3672   Vector2 relativeValue(targetValue - startValue);
3673   float delay = 0.5f;
3674   animation.AnimateBy(Property(actor, index),
3675                       relativeValue,
3676                       TimePeriod(delay, durationSeconds - delay));
3677
3678   // Start the animation
3679   animation.Play();
3680
3681   bool signalReceived(false);
3682   AnimationFinishCheck finishCheck(signalReceived);
3683   animation.FinishedSignal().Connect(&application, finishCheck);
3684
3685   application.SendNotification();
3686   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3687
3688   // We didn't expect the animation to finish yet
3689   application.SendNotification();
3690   finishCheck.CheckSignalNotReceived();
3691   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3692
3693   application.SendNotification();
3694   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3695
3696   // We didn't expect the animation to finish yet
3697   application.SendNotification();
3698   finishCheck.CheckSignalNotReceived();
3699   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3700
3701   application.SendNotification();
3702   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3703
3704   // We did expect the animation to finish
3705   application.SendNotification();
3706   finishCheck.CheckSignalReceived();
3707   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3708
3709   // Check that nothing has changed after a couple of buffer swaps
3710   application.Render(0);
3711   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3712   application.Render(0);
3713   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3714   END_TEST;
3715 }
3716
3717 int UtcDaliAnimationAnimateByVector2AlphaFunctionTimePeriodP(void)
3718 {
3719   TestApplication application;
3720
3721   Actor actor = Actor::New();
3722
3723   // Register a Vector2 property
3724   Vector2 startValue(5.0f, 5.0f);
3725   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3726   Stage::GetCurrent().Add(actor);
3727   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
3728   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3729
3730   // Build the animation
3731   float durationSeconds(1.0f);
3732   Animation animation = Animation::New(durationSeconds);
3733   Vector2 targetValue(10.0f, 10.0f);
3734   Vector2 relativeValue(targetValue - startValue);
3735   float delay = 0.5f;
3736   animation.AnimateBy(Property(actor, index),
3737                       relativeValue,
3738                       AlphaFunction::LINEAR,
3739                       TimePeriod(delay, durationSeconds - delay));
3740
3741   // Start the animation
3742   animation.Play();
3743
3744   bool signalReceived(false);
3745   AnimationFinishCheck finishCheck(signalReceived);
3746   animation.FinishedSignal().Connect(&application, finishCheck);
3747
3748   application.SendNotification();
3749   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3750
3751   // We didn't expect the animation to finish yet
3752   application.SendNotification();
3753   finishCheck.CheckSignalNotReceived();
3754   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
3755
3756   application.SendNotification();
3757   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3758
3759   // We didn't expect the animation to finish yet
3760   application.SendNotification();
3761   finishCheck.CheckSignalNotReceived();
3762   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3763
3764   application.SendNotification();
3765   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3766
3767   // We did expect the animation to finish
3768   application.SendNotification();
3769   finishCheck.CheckSignalReceived();
3770   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3771
3772   // Check that nothing has changed after a couple of buffer swaps
3773   application.Render(0);
3774   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3775   application.Render(0);
3776   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
3777   END_TEST;
3778 }
3779
3780 int UtcDaliAnimationAnimateByVector3P(void)
3781 {
3782   TestApplication application;
3783
3784   Actor actor = Actor::New();
3785
3786   // Register a Vector3 property
3787   Vector3 startValue(10.0f, 10.0f, 10.0f);
3788   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3789   Stage::GetCurrent().Add(actor);
3790   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
3791   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3792
3793   // Build the animation
3794   float durationSeconds(2.0f);
3795   Animation animation = Animation::New(durationSeconds);
3796   Vector3 targetValue(60.0f, 60.0f, 60.0f);
3797   Vector3 relativeValue(targetValue - startValue);
3798   animation.AnimateBy(Property(actor, index), relativeValue);
3799
3800   Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3801
3802   // Start the animation
3803   animation.Play();
3804
3805   bool signalReceived(false);
3806   AnimationFinishCheck finishCheck(signalReceived);
3807   animation.FinishedSignal().Connect(&application, finishCheck);
3808
3809   application.SendNotification();
3810   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3811
3812   // We didn't expect the animation to finish yet
3813   application.SendNotification();
3814   finishCheck.CheckSignalNotReceived();
3815   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
3816
3817   application.SendNotification();
3818   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3819
3820   // We did expect the animation to finish
3821   application.SendNotification();
3822   finishCheck.CheckSignalReceived();
3823   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3824
3825   // Check that nothing has changed after a couple of buffer swaps
3826   application.Render(0);
3827   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3828   application.Render(0);
3829   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3830   END_TEST;
3831 }
3832
3833 int UtcDaliAnimationAnimateByVector3AlphaFunctionP(void)
3834 {
3835   TestApplication application;
3836
3837   Actor actor = Actor::New();
3838
3839   // Register a Vector3 property
3840   Vector3 startValue(100.0f, 100.0f, 100.0f);
3841   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3842   Stage::GetCurrent().Add(actor);
3843   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
3844   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3845
3846   // Build the animation
3847   float durationSeconds(1.0f);
3848   Animation animation = Animation::New(durationSeconds);
3849   Vector3 targetValue(20.0f, 20.0f, 20.0f);
3850   Vector3 relativeValue(targetValue - startValue);
3851   animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
3852
3853   Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
3854
3855   // Start the animation
3856   animation.Play();
3857
3858   bool signalReceived(false);
3859   AnimationFinishCheck finishCheck(signalReceived);
3860   animation.FinishedSignal().Connect(&application, finishCheck);
3861
3862   application.SendNotification();
3863   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
3864
3865   // We didn't expect the animation to finish yet
3866   application.SendNotification();
3867   finishCheck.CheckSignalNotReceived();
3868
3869   // The position should have moved more, than with a linear alpha function
3870   Vector3 current(DevelHandle::GetCurrentProperty< Vector3 >( actor, index ));
3871   DALI_TEST_CHECK( current.x < ninetyFivePercentProgress.x );
3872   DALI_TEST_CHECK( current.y < ninetyFivePercentProgress.y );
3873   DALI_TEST_CHECK( current.z < ninetyFivePercentProgress.z );
3874
3875   application.SendNotification();
3876   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
3877
3878   // We did expect the animation to finish
3879   application.SendNotification();
3880   finishCheck.CheckSignalReceived();
3881   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3882
3883   // Check that nothing has changed after a couple of buffer swaps
3884   application.Render(0);
3885   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3886   application.Render(0);
3887   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3888   END_TEST;
3889 }
3890
3891 int UtcDaliAnimationAnimateByVector3TimePeriodP(void)
3892 {
3893   TestApplication application;
3894
3895   Actor actor = Actor::New();
3896
3897   // Register a Vector3 property
3898   Vector3 startValue(10.0f, 10.0f, 10.0f);
3899   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3900   Stage::GetCurrent().Add(actor);
3901   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
3902   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3903
3904   // Build the animation
3905   float durationSeconds(1.0f);
3906   Animation animation = Animation::New(durationSeconds);
3907   Vector3 targetValue(30.0f, 30.0f, 30.0f);
3908   Vector3 relativeValue(targetValue - startValue);
3909   float delay = 0.5f;
3910   animation.AnimateBy(Property(actor, index),
3911                       relativeValue,
3912                       TimePeriod(delay, durationSeconds - delay));
3913
3914   // Start the animation
3915   animation.Play();
3916
3917   bool signalReceived(false);
3918   AnimationFinishCheck finishCheck(signalReceived);
3919   animation.FinishedSignal().Connect(&application, finishCheck);
3920
3921   application.SendNotification();
3922   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3923
3924   // We didn't expect the animation to finish yet
3925   application.SendNotification();
3926   finishCheck.CheckSignalNotReceived();
3927   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3928
3929   application.SendNotification();
3930   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3931
3932   // We didn't expect the animation to finish yet
3933   application.SendNotification();
3934   finishCheck.CheckSignalNotReceived();
3935   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3936
3937   application.SendNotification();
3938   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
3939
3940   // We did expect the animation to finish
3941   application.SendNotification();
3942   finishCheck.CheckSignalReceived();
3943   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3944
3945   // Check that nothing has changed after a couple of buffer swaps
3946   application.Render(0);
3947   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3948   application.Render(0);
3949   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
3950   END_TEST;
3951 }
3952
3953 int UtcDaliAnimationAnimateByVector3AlphaFunctionTimePeriodP(void)
3954 {
3955   TestApplication application;
3956
3957   Actor actor = Actor::New();
3958
3959   // Register a Vector3 property
3960   Vector3 startValue(5.0f, 5.0f, 5.0f);
3961   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
3962   Stage::GetCurrent().Add(actor);
3963   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
3964   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3965
3966   // Build the animation
3967   float durationSeconds(1.0f);
3968   Animation animation = Animation::New(durationSeconds);
3969   Vector3 targetValue(10.0f, 10.0f, 10.0f);
3970   Vector3 relativeValue(targetValue - startValue);
3971   float delay = 0.5f;
3972   animation.AnimateBy(Property(actor, index),
3973                       relativeValue,
3974                       AlphaFunction::LINEAR,
3975                       TimePeriod(delay, durationSeconds - delay));
3976
3977   // Start the animation
3978   animation.Play();
3979
3980   bool signalReceived(false);
3981   AnimationFinishCheck finishCheck(signalReceived);
3982   animation.FinishedSignal().Connect(&application, finishCheck);
3983
3984   application.SendNotification();
3985   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
3986
3987   // We didn't expect the animation to finish yet
3988   application.SendNotification();
3989   finishCheck.CheckSignalNotReceived();
3990   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
3991
3992   application.SendNotification();
3993   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
3994
3995   // We didn't expect the animation to finish yet
3996   application.SendNotification();
3997   finishCheck.CheckSignalNotReceived();
3998   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
3999
4000   application.SendNotification();
4001   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4002
4003   // We did expect the animation to finish
4004   application.SendNotification();
4005   finishCheck.CheckSignalReceived();
4006   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
4007
4008   // Check that nothing has changed after a couple of buffer swaps
4009   application.Render(0);
4010   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
4011   application.Render(0);
4012   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
4013   END_TEST;
4014 }
4015
4016 int UtcDaliAnimationAnimateByVector4P(void)
4017 {
4018   TestApplication application;
4019
4020   Actor actor = Actor::New();
4021
4022   // Register a Vector4 property
4023   Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
4024   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
4025   Stage::GetCurrent().Add(actor);
4026   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
4027   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4028
4029   // Build the animation
4030   float durationSeconds(2.0f);
4031   Animation animation = Animation::New(durationSeconds);
4032   Vector4 targetValue(60.0f, 60.0f, 60.0f, 60.0f);
4033   Vector4 relativeValue(targetValue - startValue);
4034   animation.AnimateBy(Property(actor, index), relativeValue);
4035
4036   Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
4037
4038   // Start the animation
4039   animation.Play();
4040
4041   bool signalReceived(false);
4042   AnimationFinishCheck finishCheck(signalReceived);
4043   animation.FinishedSignal().Connect(&application, finishCheck);
4044
4045   application.SendNotification();
4046   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4047
4048   // We didn't expect the animation to finish yet
4049   application.SendNotification();
4050   finishCheck.CheckSignalNotReceived();
4051   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
4052
4053   application.SendNotification();
4054   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4055
4056   // We did expect the animation to finish
4057   application.SendNotification();
4058   finishCheck.CheckSignalReceived();
4059   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4060
4061   // Check that nothing has changed after a couple of buffer swaps
4062   application.Render(0);
4063   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4064   application.Render(0);
4065   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4066   END_TEST;
4067 }
4068
4069 int UtcDaliAnimationAnimateByVector4AlphaFunctionP(void)
4070 {
4071   TestApplication application;
4072
4073   Actor actor = Actor::New();
4074
4075   // Register a Vector4 property
4076   Vector4 startValue(100.0f, 100.0f, 100.0f, 100.0f);
4077   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
4078   Stage::GetCurrent().Add(actor);
4079   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
4080   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4081
4082   // Build the animation
4083   float durationSeconds(1.0f);
4084   Animation animation = Animation::New(durationSeconds);
4085   Vector4 targetValue(20.0f, 20.0f, 20.0f, 20.0f);
4086   Vector4 relativeValue(targetValue - startValue);
4087   animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
4088
4089   Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
4090
4091   // Start the animation
4092   animation.Play();
4093
4094   bool signalReceived(false);
4095   AnimationFinishCheck finishCheck(signalReceived);
4096   animation.FinishedSignal().Connect(&application, finishCheck);
4097
4098   application.SendNotification();
4099   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4100
4101   // We didn't expect the animation to finish yet
4102   application.SendNotification();
4103   finishCheck.CheckSignalNotReceived();
4104
4105   // The position should have moved more, than with a linear alpha function
4106   Vector4 current( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ) );
4107   DALI_TEST_CHECK( current.x < ninetyFivePercentProgress.x );
4108   DALI_TEST_CHECK( current.y < ninetyFivePercentProgress.y );
4109   DALI_TEST_CHECK( current.z < ninetyFivePercentProgress.z );
4110   DALI_TEST_CHECK( current.w < ninetyFivePercentProgress.w );
4111
4112   application.SendNotification();
4113   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4114
4115   // We did expect the animation to finish
4116   application.SendNotification();
4117   finishCheck.CheckSignalReceived();
4118   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4119
4120   // Check that nothing has changed after a couple of buffer swaps
4121   application.Render(0);
4122   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4123   application.Render(0);
4124   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4125   END_TEST;
4126 }
4127
4128 int UtcDaliAnimationAnimateByVector4TimePeriodP(void)
4129 {
4130   TestApplication application;
4131
4132   Actor actor = Actor::New();
4133
4134   // Register a Vector4 property
4135   Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
4136   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
4137   Stage::GetCurrent().Add(actor);
4138   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
4139   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4140
4141   // Build the animation
4142   float durationSeconds(1.0f);
4143   Animation animation = Animation::New(durationSeconds);
4144   Vector4 targetValue(30.0f, 30.0f, 30.0f, 30.0f);
4145   Vector4 relativeValue(targetValue - startValue);
4146   float delay = 0.5f;
4147   animation.AnimateBy(Property(actor, index),
4148                       relativeValue,
4149                       TimePeriod(delay, durationSeconds - delay));
4150
4151   // Start the animation
4152   animation.Play();
4153
4154   bool signalReceived(false);
4155   AnimationFinishCheck finishCheck(signalReceived);
4156   animation.FinishedSignal().Connect(&application, finishCheck);
4157
4158   application.SendNotification();
4159   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
4160
4161   // We didn't expect the animation to finish yet
4162   application.SendNotification();
4163   finishCheck.CheckSignalNotReceived();
4164   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4165
4166   application.SendNotification();
4167   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
4168
4169   // We didn't expect the animation to finish yet
4170   application.SendNotification();
4171   finishCheck.CheckSignalNotReceived();
4172   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
4173
4174   application.SendNotification();
4175   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4176
4177   // We did expect the animation to finish
4178   application.SendNotification();
4179   finishCheck.CheckSignalReceived();
4180   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4181
4182   // Check that nothing has changed after a couple of buffer swaps
4183   application.Render(0);
4184   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4185   application.Render(0);
4186   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4187   END_TEST;
4188 }
4189
4190 int UtcDaliAnimationAnimateByVector4AlphaFunctionTimePeriodP(void)
4191 {
4192   TestApplication application;
4193
4194   Actor actor = Actor::New();
4195
4196   // Register a Vector4 property
4197   Vector4 startValue(5.0f, 5.0f, 5.0f, 5.0f);
4198   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
4199   Stage::GetCurrent().Add(actor);
4200   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
4201   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4202
4203   // Build the animation
4204   float durationSeconds(1.0f);
4205   Animation animation = Animation::New(durationSeconds);
4206   Vector4 targetValue(10.0f, 10.0f, 10.0f, 10.0f);
4207   Vector4 relativeValue(targetValue - startValue);
4208   float delay = 0.5f;
4209   animation.AnimateBy(Property(actor, index),
4210                       relativeValue,
4211                       AlphaFunction::LINEAR,
4212                       TimePeriod(delay, durationSeconds - delay));
4213
4214   // Start the animation
4215   animation.Play();
4216
4217   bool signalReceived(false);
4218   AnimationFinishCheck finishCheck(signalReceived);
4219   animation.FinishedSignal().Connect(&application, finishCheck);
4220
4221   application.SendNotification();
4222   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
4223
4224   // We didn't expect the animation to finish yet
4225   application.SendNotification();
4226   finishCheck.CheckSignalNotReceived();
4227   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
4228
4229   application.SendNotification();
4230   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
4231
4232   // We didn't expect the animation to finish yet
4233   application.SendNotification();
4234   finishCheck.CheckSignalNotReceived();
4235   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
4236
4237   application.SendNotification();
4238   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4239
4240   // We did expect the animation to finish
4241   application.SendNotification();
4242   finishCheck.CheckSignalReceived();
4243   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4244
4245   // Check that nothing has changed after a couple of buffer swaps
4246   application.Render(0);
4247   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4248   application.Render(0);
4249   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
4250   END_TEST;
4251 }
4252
4253 int UtcDaliAnimationAnimateByActorPositionP(void)
4254 {
4255   TestApplication application;
4256
4257   Actor actor = Actor::New();
4258   Vector3 startPosition(10.0f, 10.0f, 10.0f);
4259   actor.SetPosition(startPosition);
4260   Stage::GetCurrent().Add(actor);
4261   application.SendNotification();
4262   application.Render(0);
4263   DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4264
4265   // Build the animation
4266   float durationSeconds(1.0f);
4267   Animation animation = Animation::New(durationSeconds);
4268   Vector3 targetPosition(20.0f, 20.0f, 20.0f);
4269   Vector3 relativePosition(targetPosition - startPosition);
4270   animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition);
4271
4272   Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
4273
4274   // Start the animation
4275   animation.Play();
4276
4277   bool signalReceived(false);
4278   AnimationFinishCheck finishCheck(signalReceived);
4279   animation.FinishedSignal().Connect(&application, finishCheck);
4280
4281   application.SendNotification();
4282   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4283
4284   // We didn't expect the animation to finish yet
4285   application.SendNotification();
4286   finishCheck.CheckSignalNotReceived();
4287   DALI_TEST_EQUALS( actor.GetCurrentPosition(), ninetyFivePercentProgress, TEST_LOCATION );
4288
4289   application.SendNotification();
4290   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4291
4292   // We did expect the animation to finish
4293   application.SendNotification();
4294   finishCheck.CheckSignalReceived();
4295   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4296
4297   // Check that nothing has changed after a couple of buffer swaps
4298   application.Render(0);
4299   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4300   application.Render(0);
4301   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4302   END_TEST;
4303 }
4304
4305 int UtcDaliAnimationAnimateByActorPositionAlphaFunctionP(void)
4306 {
4307   TestApplication application;
4308
4309   Actor actor = Actor::New();
4310   Vector3 startPosition(10.0f, 10.0f, 10.0f);
4311   actor.SetPosition(startPosition);
4312   Stage::GetCurrent().Add(actor);
4313   application.SendNotification();
4314   application.Render(0);
4315   DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4316
4317   // Build the animation
4318   float durationSeconds(1.0f);
4319   Animation animation = Animation::New(durationSeconds);
4320   Vector3 targetPosition(20.0f, 20.0f, 20.0f);
4321   Vector3 relativePosition(targetPosition - startPosition);
4322   animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition, AlphaFunction::EASE_OUT);
4323
4324   Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
4325
4326   // Start the animation
4327   animation.Play();
4328
4329   bool signalReceived(false);
4330   AnimationFinishCheck finishCheck(signalReceived);
4331   animation.FinishedSignal().Connect(&application, finishCheck);
4332
4333   application.SendNotification();
4334   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4335
4336   // We didn't expect the animation to finish yet
4337   application.SendNotification();
4338   finishCheck.CheckSignalNotReceived();
4339
4340   // The position should have moved more, than with a linear alpha function
4341   Vector3 current(actor.GetCurrentPosition());
4342   DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
4343   DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
4344   DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
4345
4346   application.SendNotification();
4347   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4348
4349   // We did expect the animation to finish
4350   application.SendNotification();
4351   finishCheck.CheckSignalReceived();
4352   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4353
4354   // Check that nothing has changed after a couple of buffer swaps
4355   application.Render(0);
4356   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4357   application.Render(0);
4358   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4359   END_TEST;
4360 }
4361
4362 int UtcDaliAnimationAnimateByActorPositionTimePeriodP(void)
4363 {
4364   TestApplication application;
4365
4366   Actor actor = Actor::New();
4367   Vector3 startPosition(10.0f, 10.0f, 10.0f);
4368   actor.SetPosition(startPosition);
4369   Stage::GetCurrent().Add(actor);
4370   application.SendNotification();
4371   application.Render(0);
4372   DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4373
4374   // Build the animation
4375   float durationSeconds(1.0f);
4376   Animation animation = Animation::New(durationSeconds);
4377   Vector3 targetPosition(20.0f, 20.0f, 20.0f);
4378   Vector3 relativePosition(targetPosition - startPosition);
4379   float delay = 0.5f;
4380   animation.AnimateBy(Property(actor, Actor::Property::POSITION),
4381                       relativePosition,
4382                       TimePeriod(delay, durationSeconds - delay));
4383
4384   Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
4385
4386   // Start the animation
4387   animation.Play();
4388
4389   bool signalReceived(false);
4390   AnimationFinishCheck finishCheck(signalReceived);
4391   animation.FinishedSignal().Connect(&application, finishCheck);
4392
4393   application.SendNotification();
4394   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
4395
4396   // We didn't expect the animation to finish yet
4397   application.SendNotification();
4398   finishCheck.CheckSignalNotReceived();
4399   DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4400
4401   application.SendNotification();
4402   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
4403
4404   // We did expect the animation to finish
4405   application.SendNotification();
4406   finishCheck.CheckSignalReceived();
4407   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4408
4409   // Check that nothing has changed after a couple of buffer swaps
4410   application.Render(0);
4411   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4412   application.Render(0);
4413   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4414   END_TEST;
4415 }
4416
4417 int UtcDaliAnimationAnimateByActorPositionAlphaFunctionTimePeriodP(void)
4418 {
4419   TestApplication application;
4420
4421   Actor actor = Actor::New();
4422   Vector3 startPosition(10.0f, 10.0f, 10.0f);
4423   actor.SetPosition(startPosition);
4424   Stage::GetCurrent().Add(actor);
4425   application.SendNotification();
4426   application.Render(0);
4427   DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4428
4429   // Build the animation
4430   float durationSeconds(1.0f);
4431   Animation animation = Animation::New(durationSeconds);
4432   Vector3 targetPosition(20.0f, 20.0f, 20.0f);
4433   Vector3 relativePosition(targetPosition - startPosition);
4434   float delay = 0.5f;
4435   animation.AnimateBy(Property(actor, Actor::Property::POSITION),
4436                       relativePosition,
4437                       AlphaFunction::LINEAR,
4438                       TimePeriod(delay, durationSeconds - delay));
4439
4440   Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
4441
4442   // Start the animation
4443   animation.Play();
4444
4445   bool signalReceived(false);
4446   AnimationFinishCheck finishCheck(signalReceived);
4447   animation.FinishedSignal().Connect(&application, finishCheck);
4448
4449   application.SendNotification();
4450   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
4451
4452   // We didn't expect the animation to finish yet
4453   application.SendNotification();
4454   finishCheck.CheckSignalNotReceived();
4455   DALI_TEST_EQUALS( actor.GetCurrentPosition(), startPosition, TEST_LOCATION );
4456
4457   application.SendNotification();
4458   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
4459
4460   // We did expect the animation to finish
4461   application.SendNotification();
4462   finishCheck.CheckSignalReceived();
4463   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4464
4465   // Check that nothing has changed after a couple of buffer swaps
4466   application.Render(0);
4467   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4468   application.Render(0);
4469   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
4470   END_TEST;
4471 }
4472
4473 int UtcDaliAnimationAnimateByActorOrientationP1(void)
4474 {
4475   TestApplication application;
4476
4477   Actor actor = Actor::New();
4478   actor.SetOrientation( Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
4479   Stage::GetCurrent().Add(actor);
4480   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
4481
4482   // Build the animation
4483   float durationSeconds(1.0f);
4484   Animation animation = Animation::New(durationSeconds);
4485   Degree relativeRotationDegrees(360.0f);
4486   Radian relativeRotationRadians(relativeRotationDegrees);
4487   animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ) );
4488
4489   // Start the animation
4490   animation.Play();
4491
4492   bool signalReceived(false);
4493   AnimationFinishCheck finishCheck(signalReceived);
4494   animation.FinishedSignal().Connect(&application, finishCheck);
4495
4496   application.SendNotification();
4497   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
4498
4499   // We didn't expect the animation to finish yet
4500   application.SendNotification();
4501   finishCheck.CheckSignalNotReceived();
4502   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4503
4504   application.SendNotification();
4505   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
4506
4507   // We didn't expect the animation to finish yet
4508   application.SendNotification();
4509   finishCheck.CheckSignalNotReceived();
4510   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4511
4512   application.SendNotification();
4513   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
4514
4515   // We didn't expect the animation to finish yet
4516   application.SendNotification();
4517   finishCheck.CheckSignalNotReceived();
4518   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4519
4520   application.SendNotification();
4521   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4522
4523   // We did expect the animation to finish
4524   application.SendNotification();
4525   finishCheck.CheckSignalReceived();
4526   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4527   END_TEST;
4528 }
4529
4530 int UtcDaliAnimationAnimateByActorOrientationP2(void)
4531 {
4532   TestApplication application;
4533
4534   tet_printf("Testing that rotation angle > 360 performs full rotations\n");
4535
4536   Actor actor = Actor::New();
4537   actor.SetOrientation( Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ) );
4538   Stage::GetCurrent().Add(actor);
4539   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ), ROTATION_EPSILON, TEST_LOCATION );
4540
4541   // Build the animation
4542   float durationSeconds(1.0f);
4543   Animation animation = Animation::New(durationSeconds);
4544   Degree relativeRotationDegrees(710.0f);
4545   Radian relativeRotationRadians(relativeRotationDegrees);
4546
4547   animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), AngleAxis( relativeRotationRadians, Vector3::ZAXIS ) );
4548
4549   // Start the animation
4550   animation.Play();
4551
4552   bool signalReceived(false);
4553   AnimationFinishCheck finishCheck(signalReceived);
4554   animation.FinishedSignal().Connect(&application, finishCheck);
4555
4556   application.SendNotification();
4557   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
4558
4559   // We didn't expect the animation to finish yet
4560   application.SendNotification();
4561   finishCheck.CheckSignalNotReceived();
4562   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.25f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4563
4564   application.SendNotification();
4565   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
4566
4567   // We didn't expect the animation to finish yet
4568   application.SendNotification();
4569   finishCheck.CheckSignalNotReceived();
4570   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.5f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4571
4572   application.SendNotification();
4573   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
4574
4575   // We didn't expect the animation to finish yet
4576   application.SendNotification();
4577   finishCheck.CheckSignalNotReceived();
4578   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.75f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4579
4580   application.SendNotification();
4581   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4582
4583   // We did expect the animation to finish
4584   application.SendNotification();
4585   finishCheck.CheckSignalReceived();
4586   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4587   END_TEST;
4588 }
4589
4590
4591 int UtcDaliAnimationAnimateByActorOrientationP3(void)
4592 {
4593   TestApplication application;
4594
4595   tet_printf("Testing that rotation angle > 360 performs partial rotations when cast to Quaternion\n");
4596
4597   Actor actor = Actor::New();
4598   actor.SetOrientation( Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ) );
4599   Stage::GetCurrent().Add(actor);
4600   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ), ROTATION_EPSILON, TEST_LOCATION );
4601
4602   // Build the animation
4603   float durationSeconds(1.0f);
4604   Animation animation = Animation::New(durationSeconds);
4605   Degree relativeRotationDegrees(730.0f);
4606   Radian relativeRotationRadians(relativeRotationDegrees);
4607
4608   Radian actualRotationRadians( Degree(10.0f) );
4609
4610   animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::ZAXIS ) );
4611
4612   // Start the animation
4613   animation.Play();
4614
4615   bool signalReceived(false);
4616   AnimationFinishCheck finishCheck(signalReceived);
4617   animation.FinishedSignal().Connect(&application, finishCheck);
4618
4619   application.SendNotification();
4620   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
4621
4622   // We didn't expect the animation to finish yet
4623   application.SendNotification();
4624   finishCheck.CheckSignalNotReceived();
4625   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(actualRotationRadians * 0.25f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4626
4627   application.SendNotification();
4628   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
4629
4630   // We didn't expect the animation to finish yet
4631   application.SendNotification();
4632   finishCheck.CheckSignalNotReceived();
4633   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(actualRotationRadians * 0.5f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4634
4635   application.SendNotification();
4636   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
4637
4638   // We didn't expect the animation to finish yet
4639   application.SendNotification();
4640   finishCheck.CheckSignalNotReceived();
4641   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(actualRotationRadians * 0.75f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4642
4643   application.SendNotification();
4644   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4645
4646   // We did expect the animation to finish
4647   application.SendNotification();
4648   finishCheck.CheckSignalReceived();
4649   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(actualRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4650   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
4651   END_TEST;
4652 }
4653
4654
4655 int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionP(void)
4656 {
4657   TestApplication application;
4658
4659   Actor actor = Actor::New();
4660   actor.SetOrientation( Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
4661   Stage::GetCurrent().Add(actor);
4662   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
4663
4664   // Build the animation
4665   float durationSeconds(1.0f);
4666   Animation animation = Animation::New(durationSeconds);
4667   Degree relativeRotationDegrees(360.0f);
4668   Radian relativeRotationRadians(relativeRotationDegrees);
4669   animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ), AlphaFunction::EASE_IN );
4670
4671   // Start the animation
4672   animation.Play();
4673
4674   bool signalReceived(false);
4675   AnimationFinishCheck finishCheck(signalReceived);
4676   animation.FinishedSignal().Connect(&application, finishCheck);
4677
4678   application.SendNotification();
4679   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
4680
4681   // We didn't expect the animation to finish yet
4682   application.SendNotification();
4683   finishCheck.CheckSignalNotReceived();
4684   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.25f*0.25f*0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4685
4686   application.SendNotification();
4687   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
4688
4689   // We didn't expect the animation to finish yet
4690   application.SendNotification();
4691   finishCheck.CheckSignalNotReceived();
4692   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.5f*0.5f*0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4693
4694   application.SendNotification();
4695   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
4696
4697   // We didn't expect the animation to finish yet
4698   application.SendNotification();
4699   finishCheck.CheckSignalNotReceived();
4700   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.75f*0.75f*0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4701
4702   application.SendNotification();
4703   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4704
4705   // We did expect the animation to finish
4706   application.SendNotification();
4707   finishCheck.CheckSignalReceived();
4708   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4709   END_TEST;
4710 }
4711
4712 int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionTimePeriodP(void)
4713 {
4714   TestApplication application;
4715
4716   Actor actor = Actor::New();
4717   actor.SetOrientation( Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
4718   Stage::GetCurrent().Add(actor);
4719   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
4720
4721   // Build the animation
4722   float durationSeconds(1.0f);
4723   Animation animation = Animation::New(durationSeconds);
4724   Degree relativeRotationDegrees(360.0f);
4725   Radian relativeRotationRadians(relativeRotationDegrees);
4726   float delay = 0.3f;
4727   animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ),
4728                        AlphaFunction::EASE_IN, TimePeriod( delay, durationSeconds - delay ) );
4729
4730   // Start the animation
4731   animation.Play();
4732
4733   bool signalReceived(false);
4734   AnimationFinishCheck finishCheck(signalReceived);
4735   animation.FinishedSignal().Connect(&application, finishCheck);
4736
4737   application.SendNotification();
4738   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
4739
4740   // We didn't expect the animation to finish yet
4741   application.SendNotification();
4742   finishCheck.CheckSignalNotReceived();
4743   float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
4744   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4745
4746   application.SendNotification();
4747   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
4748
4749   // We didn't expect the animation to finish yet
4750   application.SendNotification();
4751   finishCheck.CheckSignalNotReceived();
4752   progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
4753   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4754
4755   application.SendNotification();
4756   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
4757
4758   // We didn't expect the animation to finish yet
4759   application.SendNotification();
4760   finishCheck.CheckSignalNotReceived();
4761   progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
4762   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4763
4764   application.SendNotification();
4765   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
4766
4767   // We did expect the animation to finish
4768   application.SendNotification();
4769   finishCheck.CheckSignalReceived();
4770   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
4771   END_TEST;
4772 }
4773
4774 int UtcDaliAnimationAnimateByActorScaleP(void)
4775 {
4776   TestApplication application;
4777
4778   Actor actor = Actor::New();
4779   Stage::GetCurrent().Add(actor);
4780   DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
4781
4782   // Build the animation
4783   float durationSeconds(1.0f);
4784   Animation animation = Animation::New(durationSeconds);
4785   Vector3 targetScale(2.0f, 2.0f, 2.0f);
4786   Vector3 relativeScale(targetScale - Vector3::ONE);
4787   animation.AnimateBy( Property( actor, Actor::Property::SCALE ), Vector3( relativeScale.x, relativeScale.y, relativeScale.z ) );
4788
4789   Vector3 ninetyNinePercentProgress(Vector3::ONE + relativeScale*0.99f);
4790
4791   // Start the animation
4792   animation.Play();
4793
4794   bool signalReceived(false);
4795   AnimationFinishCheck finishCheck(signalReceived);
4796   animation.FinishedSignal().Connect(&application, finishCheck);
4797
4798   application.SendNotification();
4799   application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
4800
4801   // We didn't expect the animation to finish yet
4802   application.SendNotification();
4803   finishCheck.CheckSignalNotReceived();
4804   DALI_TEST_EQUALS( actor.GetCurrentScale(), ninetyNinePercentProgress, TEST_LOCATION );
4805
4806   application.SendNotification();
4807   application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
4808
4809   // We did expect the animation to finish
4810   application.SendNotification();
4811   finishCheck.CheckSignalReceived();
4812   DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
4813
4814   // Reset everything
4815   finishCheck.Reset();
4816   actor.SetScale(Vector3::ONE);
4817   application.SendNotification();
4818   application.Render(0);
4819   DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
4820
4821   // Repeat with a different (ease-in) alpha function
4822   animation = Animation::New(durationSeconds);
4823   animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunction::EASE_IN );
4824   animation.FinishedSignal().Connect(&application, finishCheck);
4825   animation.Play();
4826
4827   application.SendNotification();
4828   application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
4829
4830   // We didn't expect the animation to finish yet
4831   application.SendNotification();
4832   finishCheck.CheckSignalNotReceived();
4833
4834   // The scale should have grown less, than with a linear alpha function
4835   Vector3 current(actor.GetCurrentScale());
4836   DALI_TEST_CHECK( current.x > 1.0f );
4837   DALI_TEST_CHECK( current.y > 1.0f );
4838   DALI_TEST_CHECK( current.z > 1.0f );
4839   DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
4840   DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
4841   DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
4842
4843   application.SendNotification();
4844   application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
4845
4846   // We did expect the animation to finish
4847   application.SendNotification();
4848   finishCheck.CheckSignalReceived();
4849   DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
4850
4851   // Reset everything
4852   finishCheck.Reset();
4853   actor.SetScale(Vector3::ONE);
4854   application.SendNotification();
4855   application.Render(0);
4856   DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
4857
4858   // Repeat with a delay
4859   float delay = 0.5f;
4860   animation = Animation::New(durationSeconds);
4861   animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
4862   animation.FinishedSignal().Connect(&application, finishCheck);
4863   animation.Play();
4864
4865   application.SendNotification();
4866   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
4867
4868   // We didn't expect the animation to finish yet
4869   application.SendNotification();
4870   finishCheck.CheckSignalNotReceived();
4871   DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
4872
4873   application.SendNotification();
4874   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
4875
4876   // We did expect the animation to finish
4877   application.SendNotification();
4878   finishCheck.CheckSignalReceived();
4879   DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
4880   END_TEST;
4881 }
4882
4883 int UtcDaliAnimationAnimateToBooleanP(void)
4884 {
4885   TestApplication application;
4886
4887   Actor actor = Actor::New();
4888
4889   // Register a boolean property
4890   const bool startValue(false);
4891   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
4892   Stage::GetCurrent().Add(actor);
4893   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
4894   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
4895
4896   // Build the animation
4897   float durationSeconds(2.0f);
4898   Animation animation = Animation::New(durationSeconds);
4899   const bool targetValue( !startValue );
4900   animation.AnimateTo(Property(actor, index), targetValue);
4901
4902   // Start the animation
4903   animation.Play();
4904
4905   bool signalReceived(false);
4906   AnimationFinishCheck finishCheck(signalReceived);
4907   animation.FinishedSignal().Connect(&application, finishCheck);
4908
4909   application.SendNotification();
4910   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4911
4912   // We didn't expect the animation to finish yet
4913   application.SendNotification();
4914   finishCheck.CheckSignalNotReceived();
4915   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
4916
4917   application.SendNotification();
4918   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4919
4920   // We did expect the animation to finish
4921   application.SendNotification();
4922   finishCheck.CheckSignalReceived();
4923   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
4924
4925   // Check that nothing has changed after a couple of buffer swaps
4926   application.Render(0);
4927   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
4928   application.Render(0);
4929   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
4930
4931   // Repeat with target value "false"
4932   animation = Animation::New(durationSeconds);
4933   const bool finalValue( !targetValue );
4934   animation.AnimateTo(Property(actor, index), finalValue);
4935
4936   // Start the animation
4937   animation.Play();
4938
4939   finishCheck.Reset();
4940   animation.FinishedSignal().Connect(&application, finishCheck);
4941
4942   application.SendNotification();
4943   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4944
4945   // We didn't expect the animation to finish yet
4946   application.SendNotification();
4947   finishCheck.CheckSignalNotReceived();
4948   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
4949
4950   application.SendNotification();
4951   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
4952
4953   // We did expect the animation to finish
4954   application.SendNotification();
4955   finishCheck.CheckSignalReceived();
4956   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
4957
4958   // Check that nothing has changed after a couple of buffer swaps
4959   application.Render(0);
4960   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
4961   application.Render(0);
4962   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
4963   END_TEST;
4964 }
4965
4966 int UtcDaliAnimationAnimateToBooleanAlphaFunctionP(void)
4967 {
4968   TestApplication application;
4969
4970   Actor actor = Actor::New();
4971
4972   // Register a boolean property
4973   const bool startValue(false);
4974   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
4975   Stage::GetCurrent().Add(actor);
4976   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
4977   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
4978
4979   // Build the animation
4980   float durationSeconds(2.0f);
4981   Animation animation = Animation::New(durationSeconds);
4982   const bool targetValue( !startValue );
4983   animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction::EASE_OUT);
4984
4985   // Start the animation
4986   animation.Play();
4987
4988   bool signalReceived(false);
4989   AnimationFinishCheck finishCheck(signalReceived);
4990   animation.FinishedSignal().Connect(&application, finishCheck);
4991
4992   application.SendNotification();
4993   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
4994
4995   // We didn't expect the animation to finish yet
4996   application.SendNotification();
4997   finishCheck.CheckSignalNotReceived();
4998   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
4999
5000   application.SendNotification();
5001   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5002
5003   // We did expect the animation to finish
5004   application.SendNotification();
5005   finishCheck.CheckSignalReceived();
5006   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
5007
5008   // Check that nothing has changed after a couple of buffer swaps
5009   application.Render(0);
5010   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
5011   application.Render(0);
5012   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
5013
5014   // Repeat with target value "false"
5015   animation = Animation::New(durationSeconds);
5016   const bool finalValue( !targetValue );
5017   animation.AnimateTo(Property(actor, index), finalValue, AlphaFunction::EASE_OUT);
5018
5019   // Start the animation
5020   animation.Play();
5021
5022   finishCheck.Reset();
5023   animation.FinishedSignal().Connect(&application, finishCheck);
5024
5025   application.SendNotification();
5026   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5027
5028   // We didn't expect the animation to finish yet
5029   application.SendNotification();
5030   finishCheck.CheckSignalNotReceived();
5031   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == targetValue );
5032
5033   application.SendNotification();
5034   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5035
5036   // We did expect the animation to finish
5037   application.SendNotification();
5038   finishCheck.CheckSignalReceived();
5039   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5040
5041   // Check that nothing has changed after a couple of buffer swaps
5042   application.Render(0);
5043   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5044   application.Render(0);
5045   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5046   END_TEST;
5047 }
5048
5049 int UtcDaliAnimationAnimateToBooleanTimePeriodP(void)
5050 {
5051   TestApplication application;
5052
5053   Actor actor = Actor::New();
5054
5055   // Register a boolean property
5056   bool startValue(false);
5057   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5058   Stage::GetCurrent().Add(actor);
5059   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
5060   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
5061
5062   // Build the animation
5063   float durationSeconds(2.0f);
5064   Animation animation = Animation::New(durationSeconds);
5065   bool finalValue( !startValue );
5066   float animatorDurationSeconds(durationSeconds * 0.5f);
5067   animation.AnimateTo( Property(actor, index),
5068                        finalValue,
5069                        TimePeriod( animatorDurationSeconds ) );
5070
5071   // Start the animation
5072   animation.Play();
5073
5074   bool signalReceived(false);
5075   AnimationFinishCheck finishCheck(signalReceived);
5076   animation.FinishedSignal().Connect(&application, finishCheck);
5077
5078   application.SendNotification();
5079   application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
5080
5081   // We didn't expect the animation to finish yet
5082   application.SendNotification();
5083   finishCheck.CheckSignalNotReceived();
5084   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
5085
5086   application.SendNotification();
5087   application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
5088
5089   // We didn't expect the animation to finish yet...
5090   application.SendNotification();
5091   finishCheck.CheckSignalNotReceived();
5092
5093   // ...however we should have reached the final value
5094   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5095
5096   application.SendNotification();
5097   application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
5098
5099   // We did expect the animation to finish
5100   application.SendNotification();
5101   finishCheck.CheckSignalReceived();
5102   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5103
5104   // Check that nothing has changed after a couple of buffer swaps
5105   application.Render(0);
5106   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5107   application.Render(0);
5108   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5109   END_TEST;
5110 }
5111
5112 int UtcDaliAnimationAnimateToBooleanAlphaFunctionTimePeriodP(void)
5113 {
5114   TestApplication application;
5115
5116   Actor actor = Actor::New();
5117
5118   // Register a boolean property
5119   bool startValue(false);
5120   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5121   Stage::GetCurrent().Add(actor);
5122   DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
5123   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
5124
5125   // Build the animation
5126   float durationSeconds(2.0f);
5127   Animation animation = Animation::New(durationSeconds);
5128   bool finalValue( !startValue );
5129   float animatorDurationSeconds(durationSeconds * 0.5f);
5130   animation.AnimateTo( Property(actor, index),
5131                        finalValue,
5132                        AlphaFunction::LINEAR,
5133                        TimePeriod( animatorDurationSeconds ) );
5134
5135   // Start the animation
5136   animation.Play();
5137
5138   bool signalReceived(false);
5139   AnimationFinishCheck finishCheck(signalReceived);
5140   animation.FinishedSignal().Connect(&application, finishCheck);
5141
5142   application.SendNotification();
5143   application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
5144
5145   // We didn't expect the animation to finish yet
5146   application.SendNotification();
5147   finishCheck.CheckSignalNotReceived();
5148   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == startValue );
5149
5150   application.SendNotification();
5151   application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
5152
5153   // We didn't expect the animation to finish yet...
5154   application.SendNotification();
5155   finishCheck.CheckSignalNotReceived();
5156
5157   // ...however we should have reached the final value
5158   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5159
5160   application.SendNotification();
5161   application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
5162
5163   // We did expect the animation to finish
5164   application.SendNotification();
5165   finishCheck.CheckSignalReceived();
5166   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5167
5168   // Check that nothing has changed after a couple of buffer swaps
5169   application.Render(0);
5170   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5171   application.Render(0);
5172   DALI_TEST_CHECK( DevelHandle::GetCurrentProperty< bool >( actor, index ) == finalValue );
5173   END_TEST;
5174 }
5175
5176 int UtcDaliAnimationAnimateToFloatP(void)
5177 {
5178   TestApplication application;
5179
5180   Actor actor = Actor::New();
5181
5182   // Register a float property
5183   float startValue(10.0f);
5184   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5185   Stage::GetCurrent().Add(actor);
5186   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
5187   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5188
5189   // Build the animation
5190   float durationSeconds(2.0f);
5191   Animation animation = Animation::New(durationSeconds);
5192   float targetValue(50.0f);
5193   float relativeValue(targetValue - startValue);
5194   animation.AnimateTo(Property(actor, "testProperty"), targetValue);
5195
5196   float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5197
5198   // Start the animation
5199   animation.Play();
5200
5201   bool signalReceived(false);
5202   AnimationFinishCheck finishCheck(signalReceived);
5203   animation.FinishedSignal().Connect(&application, finishCheck);
5204
5205   application.SendNotification();
5206   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5207
5208   // We didn't expect the animation to finish yet
5209   application.SendNotification();
5210   finishCheck.CheckSignalNotReceived();
5211   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
5212
5213   application.SendNotification();
5214   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5215
5216   // We did expect the animation to finish
5217   application.SendNotification();
5218   finishCheck.CheckSignalReceived();
5219   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
5220   END_TEST;
5221 }
5222
5223 int UtcDaliAnimationAnimateToFloatAlphaFunctionP(void)
5224 {
5225   TestApplication application;
5226
5227   Actor actor = Actor::New();
5228
5229   // Register a float property
5230   float startValue(10.0f);
5231   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5232   Stage::GetCurrent().Add(actor);
5233   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
5234   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5235
5236   // Build the animation
5237   float durationSeconds(1.0f);
5238   Animation animation = Animation::New(durationSeconds);
5239   float targetValue(90.0f);
5240   float relativeValue(targetValue - startValue);
5241   animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
5242
5243   float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5244
5245   // Start the animation
5246   animation.Play();
5247
5248   bool signalReceived(false);
5249   AnimationFinishCheck finishCheck(signalReceived);
5250   animation.FinishedSignal().Connect(&application, finishCheck);
5251
5252   application.SendNotification();
5253   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5254
5255   // We didn't expect the animation to finish yet
5256   application.SendNotification();
5257   finishCheck.CheckSignalNotReceived();
5258
5259   // The position should have moved more, than with a linear alpha function
5260   float current( DevelHandle::GetCurrentProperty< float >( actor, index ) );
5261   DALI_TEST_CHECK( current > ninetyFivePercentProgress );
5262
5263   application.SendNotification();
5264   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5265
5266   // We did expect the animation to finish
5267   application.SendNotification();
5268   finishCheck.CheckSignalReceived();
5269   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
5270   END_TEST;
5271 }
5272
5273 int UtcDaliAnimationAnimateToFloatTimePeriodP(void)
5274 {
5275   TestApplication application;
5276
5277   Actor actor = Actor::New();
5278
5279   // Register a float property
5280   float startValue(10.0f);
5281   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5282   Stage::GetCurrent().Add(actor);
5283   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
5284   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5285
5286   // Build the animation
5287   float durationSeconds(1.0f);
5288   Animation animation = Animation::New(durationSeconds);
5289   float targetValue(30.0f);
5290   float relativeValue(targetValue - startValue);
5291   float delay = 0.5f;
5292   animation.AnimateTo(Property(actor, index),
5293                       targetValue,
5294                       TimePeriod(delay, durationSeconds - delay));
5295
5296   // Start the animation
5297   animation.Play();
5298
5299   bool signalReceived(false);
5300   AnimationFinishCheck finishCheck(signalReceived);
5301   animation.FinishedSignal().Connect(&application, finishCheck);
5302
5303   application.SendNotification();
5304   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5305
5306   // We didn't expect the animation to finish yet
5307   application.SendNotification();
5308   finishCheck.CheckSignalNotReceived();
5309   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5310
5311   application.SendNotification();
5312   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5313
5314   // We didn't expect the animation to finish yet
5315   application.SendNotification();
5316   finishCheck.CheckSignalNotReceived();
5317   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
5318
5319   application.SendNotification();
5320   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5321
5322   // We did expect the animation to finish
5323   application.SendNotification();
5324   finishCheck.CheckSignalReceived();
5325   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
5326   END_TEST;
5327 }
5328
5329 int UtcDaliAnimationAnimateToFloatAlphaFunctionTimePeriodP(void)
5330 {
5331   TestApplication application;
5332
5333   Actor actor = Actor::New();
5334
5335   // Register a float property
5336   float startValue(10.0f);
5337   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5338   Stage::GetCurrent().Add(actor);
5339   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
5340   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5341
5342   // Build the animation
5343   float durationSeconds(1.0f);
5344   Animation animation = Animation::New(durationSeconds);
5345   float targetValue(30.0f);
5346   float relativeValue(targetValue - startValue);
5347   float delay = 0.5f;
5348   animation.AnimateTo(Property(actor, index),
5349                       targetValue,
5350                       AlphaFunction::LINEAR,
5351                       TimePeriod(delay, durationSeconds - delay));
5352
5353   // Start the animation
5354   animation.Play();
5355
5356   bool signalReceived(false);
5357   AnimationFinishCheck finishCheck(signalReceived);
5358   animation.FinishedSignal().Connect(&application, finishCheck);
5359
5360   application.SendNotification();
5361   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5362
5363   // We didn't expect the animation to finish yet
5364   application.SendNotification();
5365   finishCheck.CheckSignalNotReceived();
5366   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
5367
5368   application.SendNotification();
5369   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5370
5371   // We didn't expect the animation to finish yet
5372   application.SendNotification();
5373   finishCheck.CheckSignalNotReceived();
5374   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
5375
5376   application.SendNotification();
5377   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5378
5379   // We did expect the animation to finish
5380   application.SendNotification();
5381   finishCheck.CheckSignalReceived();
5382   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
5383   END_TEST;
5384 }
5385
5386 int UtcDaliAnimationAnimateToIntegerP(void)
5387 {
5388   TestApplication application;
5389
5390   Actor actor = Actor::New();
5391
5392   // Register an integer property
5393   int startValue(10);
5394   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5395   Stage::GetCurrent().Add(actor);
5396   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
5397   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5398
5399   // Build the animation
5400   float durationSeconds(2.0f);
5401   Animation animation = Animation::New(durationSeconds);
5402   int targetValue(50);
5403   int relativeValue(targetValue - startValue);
5404   animation.AnimateTo(Property(actor, "testProperty"), targetValue);
5405
5406   int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
5407
5408   // Start the animation
5409   animation.Play();
5410
5411   bool signalReceived(false);
5412   AnimationFinishCheck finishCheck(signalReceived);
5413   animation.FinishedSignal().Connect(&application, finishCheck);
5414
5415   application.SendNotification();
5416   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5417
5418   // We didn't expect the animation to finish yet
5419   application.SendNotification();
5420   finishCheck.CheckSignalNotReceived();
5421   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
5422
5423   application.SendNotification();
5424   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5425
5426   // We did expect the animation to finish
5427   application.SendNotification();
5428   finishCheck.CheckSignalReceived();
5429   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
5430   END_TEST;
5431 }
5432
5433 int UtcDaliAnimationAnimateToIntegerAlphaFunctionP(void)
5434 {
5435   TestApplication application;
5436
5437   Actor actor = Actor::New();
5438
5439   // Register an integer property
5440   int startValue(10);
5441   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5442   Stage::GetCurrent().Add(actor);
5443   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
5444   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5445
5446   // Build the animation
5447   float durationSeconds(1.0f);
5448   Animation animation = Animation::New(durationSeconds);
5449   int targetValue(90);
5450   int relativeValue(targetValue - startValue);
5451   animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
5452
5453   int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
5454
5455   // Start the animation
5456   animation.Play();
5457
5458   bool signalReceived(false);
5459   AnimationFinishCheck finishCheck(signalReceived);
5460   animation.FinishedSignal().Connect(&application, finishCheck);
5461
5462   application.SendNotification();
5463   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5464
5465   // We didn't expect the animation to finish yet
5466   application.SendNotification();
5467   finishCheck.CheckSignalNotReceived();
5468
5469   // The position should have moved more, than with a linear alpha function
5470   int current( DevelHandle::GetCurrentProperty< int >( actor, index ) );
5471   DALI_TEST_CHECK( current > ninetyFivePercentProgress );
5472
5473   application.SendNotification();
5474   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5475
5476   // We did expect the animation to finish
5477   application.SendNotification();
5478   finishCheck.CheckSignalReceived();
5479   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
5480   END_TEST;
5481 }
5482
5483 int UtcDaliAnimationAnimateToIntegerTimePeriodP(void)
5484 {
5485   TestApplication application;
5486
5487   Actor actor = Actor::New();
5488
5489   // Register an integer property
5490   int startValue(10);
5491   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5492   Stage::GetCurrent().Add(actor);
5493   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
5494   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5495
5496   // Build the animation
5497   float durationSeconds(1.0f);
5498   Animation animation = Animation::New(durationSeconds);
5499   int targetValue(30);
5500   int relativeValue(targetValue - startValue);
5501   float delay = 0.5f;
5502   animation.AnimateTo(Property(actor, index),
5503                       targetValue,
5504                       TimePeriod(delay, durationSeconds - delay));
5505
5506   // Start the animation
5507   animation.Play();
5508
5509   bool signalReceived(false);
5510   AnimationFinishCheck finishCheck(signalReceived);
5511   animation.FinishedSignal().Connect(&application, finishCheck);
5512
5513   application.SendNotification();
5514   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5515
5516   // We didn't expect the animation to finish yet
5517   application.SendNotification();
5518   finishCheck.CheckSignalNotReceived();
5519   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5520
5521   application.SendNotification();
5522   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5523
5524   // We didn't expect the animation to finish yet
5525   application.SendNotification();
5526   finishCheck.CheckSignalNotReceived();
5527   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
5528
5529   application.SendNotification();
5530   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5531
5532   // We did expect the animation to finish
5533   application.SendNotification();
5534   finishCheck.CheckSignalReceived();
5535   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
5536   END_TEST;
5537 }
5538
5539 int UtcDaliAnimationAnimateToIntegerAlphaFunctionTimePeriodP(void)
5540 {
5541   TestApplication application;
5542
5543   Actor actor = Actor::New();
5544
5545   // Register an integer property
5546   int startValue(10);
5547   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5548   Stage::GetCurrent().Add(actor);
5549   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
5550   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5551
5552   // Build the animation
5553   float durationSeconds(1.0f);
5554   Animation animation = Animation::New(durationSeconds);
5555   int targetValue(30);
5556   int relativeValue(targetValue - startValue);
5557   float delay = 0.5f;
5558   animation.AnimateTo(Property(actor, index),
5559                       targetValue,
5560                       AlphaFunction::LINEAR,
5561                       TimePeriod(delay, durationSeconds - delay));
5562
5563   // Start the animation
5564   animation.Play();
5565
5566   bool signalReceived(false);
5567   AnimationFinishCheck finishCheck(signalReceived);
5568   animation.FinishedSignal().Connect(&application, finishCheck);
5569
5570   application.SendNotification();
5571   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5572
5573   // We didn't expect the animation to finish yet
5574   application.SendNotification();
5575   finishCheck.CheckSignalNotReceived();
5576   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
5577
5578   application.SendNotification();
5579   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5580
5581   // We didn't expect the animation to finish yet
5582   application.SendNotification();
5583   finishCheck.CheckSignalNotReceived();
5584   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
5585
5586   application.SendNotification();
5587   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5588
5589   // We did expect the animation to finish
5590   application.SendNotification();
5591   finishCheck.CheckSignalReceived();
5592   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), targetValue, TEST_LOCATION );
5593   END_TEST;
5594 }
5595
5596 int UtcDaliAnimationAnimateToVector2P(void)
5597 {
5598   TestApplication application;
5599
5600   Actor actor = Actor::New();
5601
5602   // Register a Vector2 property
5603   Vector2 startValue(-50.0f, -50.0f);
5604   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5605   Stage::GetCurrent().Add(actor);
5606   DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
5607   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
5608
5609   // Build the animation
5610   float durationSeconds(2.0f);
5611   Animation animation = Animation::New(durationSeconds);
5612   Vector2 targetValue(50.0f, 50.0f);
5613   Vector2 relativeValue(targetValue - startValue);
5614   animation.AnimateTo(Property(actor, index), targetValue);
5615
5616   Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5617
5618   // Start the animation
5619   animation.Play();
5620
5621   bool signalReceived(false);
5622   AnimationFinishCheck finishCheck(signalReceived);
5623   animation.FinishedSignal().Connect(&application, finishCheck);
5624
5625   application.SendNotification();
5626   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5627
5628   // We didn't expect the animation to finish yet
5629   application.SendNotification();
5630   finishCheck.CheckSignalNotReceived();
5631   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
5632
5633   application.SendNotification();
5634   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5635
5636   // We did expect the animation to finish
5637   application.SendNotification();
5638   finishCheck.CheckSignalReceived();
5639   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
5640   END_TEST;
5641 }
5642
5643 int UtcDaliAnimationAnimateToVector2AlphaFunctionP(void)
5644 {
5645   TestApplication application;
5646
5647   Actor actor = Actor::New();
5648
5649   // Register a Vector2 property
5650   Vector2 startValue(1000.0f, 1000.0f);
5651   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5652   Stage::GetCurrent().Add(actor);
5653   DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
5654   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
5655
5656   // Build the animation
5657   float durationSeconds(1.0f);
5658   Animation animation = Animation::New(durationSeconds);
5659   Vector2 targetValue(9000.0f, 9000.0f);
5660   Vector2 relativeValue(targetValue - startValue);
5661   animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction::EASE_OUT);
5662
5663   Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5664
5665   // Start the animation
5666   animation.Play();
5667
5668   bool signalReceived(false);
5669   AnimationFinishCheck finishCheck(signalReceived);
5670   animation.FinishedSignal().Connect(&application, finishCheck);
5671
5672   application.SendNotification();
5673   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5674
5675   // We didn't expect the animation to finish yet
5676   application.SendNotification();
5677   finishCheck.CheckSignalNotReceived();
5678
5679   // The position should have moved more, than with a linear alpha function
5680   Vector2 current( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ) );
5681   DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
5682   DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
5683
5684   application.SendNotification();
5685   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5686
5687   // We did expect the animation to finish
5688   application.SendNotification();
5689   finishCheck.CheckSignalReceived();
5690   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
5691   END_TEST;
5692 }
5693
5694 int UtcDaliAnimationAnimateToVector2TimePeriodP(void)
5695 {
5696   TestApplication application;
5697
5698   Actor actor = Actor::New();
5699
5700   // Register a Vector2 property
5701   Vector2 startValue(10.0f, 10.0f);
5702   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5703   Stage::GetCurrent().Add(actor);
5704   DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
5705   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
5706
5707   // Build the animation
5708   float durationSeconds(1.0f);
5709   Animation animation = Animation::New(durationSeconds);
5710   Vector2 targetValue(-10.0f, 20.0f);
5711   Vector2 relativeValue(targetValue - startValue);
5712   float delay = 0.5f;
5713   animation.AnimateTo(Property(actor, index),
5714                       targetValue,
5715                       TimePeriod(delay, durationSeconds - delay));
5716
5717   // Start the animation
5718   animation.Play();
5719
5720   bool signalReceived(false);
5721   AnimationFinishCheck finishCheck(signalReceived);
5722   animation.FinishedSignal().Connect(&application, finishCheck);
5723
5724   application.SendNotification();
5725   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5726
5727   // We didn't expect the animation to finish yet
5728   application.SendNotification();
5729   finishCheck.CheckSignalNotReceived();
5730   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
5731
5732   application.SendNotification();
5733   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5734
5735   // We didn't expect the animation to finish yet
5736   application.SendNotification();
5737   finishCheck.CheckSignalNotReceived();
5738   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
5739
5740   application.SendNotification();
5741   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5742
5743   // We did expect the animation to finish
5744   application.SendNotification();
5745   finishCheck.CheckSignalReceived();
5746   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
5747   END_TEST;
5748 }
5749
5750 int UtcDaliAnimationAnimateToVector2AlphaFunctionTimePeriodP(void)
5751 {
5752   TestApplication application;
5753
5754   Actor actor = Actor::New();
5755
5756   // Register a Vector2 property
5757   Vector2 startValue(10.0f, 10.0f);
5758   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5759   Stage::GetCurrent().Add(actor);
5760   DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
5761   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue, TEST_LOCATION );
5762
5763   // Build the animation
5764   float durationSeconds(1.0f);
5765   Animation animation = Animation::New(durationSeconds);
5766   Vector2 targetValue(30.0f, 30.0f);
5767   Vector2 relativeValue(targetValue - startValue);
5768   float delay = 0.5f;
5769   animation.AnimateTo(Property(actor, index),
5770                       targetValue,
5771                       AlphaFunction::LINEAR,
5772                       TimePeriod(delay, durationSeconds - delay));
5773
5774   // Start the animation
5775   animation.Play();
5776
5777   bool signalReceived(false);
5778   AnimationFinishCheck finishCheck(signalReceived);
5779   animation.FinishedSignal().Connect(&application, finishCheck);
5780
5781   application.SendNotification();
5782   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5783
5784   // We didn't expect the animation to finish yet
5785   application.SendNotification();
5786   finishCheck.CheckSignalNotReceived();
5787   DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
5788
5789   application.SendNotification();
5790   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5791
5792   // We didn't expect the animation to finish yet
5793   application.SendNotification();
5794   finishCheck.CheckSignalNotReceived();
5795   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
5796
5797   application.SendNotification();
5798   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5799
5800   // We did expect the animation to finish
5801   application.SendNotification();
5802   finishCheck.CheckSignalReceived();
5803   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector2 >( actor, index ), targetValue, TEST_LOCATION );
5804   END_TEST;
5805 }
5806
5807 int UtcDaliAnimationAnimateToVector3P(void)
5808 {
5809   TestApplication application;
5810
5811   Actor actor = Actor::New();
5812
5813   // Register a Vector3 property
5814   Vector3 startValue(-50.0f, -50.0f, -50.0f);
5815   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5816   Stage::GetCurrent().Add(actor);
5817   DALI_TEST_EQUALS( actor.GetProperty<Vector3>( index ), startValue, TEST_LOCATION );
5818   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
5819
5820   // Build the animation
5821   float durationSeconds(2.0f);
5822   Animation animation = Animation::New(durationSeconds);
5823   Vector3 targetValue(50.0f, 50.0f, 50.0f);
5824   Vector3 relativeValue(targetValue - startValue);
5825   animation.AnimateTo(Property(actor, index), targetValue);
5826
5827   Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5828
5829   // Start the animation
5830   animation.Play();
5831
5832   bool signalReceived(false);
5833   AnimationFinishCheck finishCheck(signalReceived);
5834   animation.FinishedSignal().Connect(&application, finishCheck);
5835
5836   application.SendNotification();
5837   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5838
5839   // We didn't expect the animation to finish yet
5840   application.SendNotification();
5841   finishCheck.CheckSignalNotReceived();
5842   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
5843
5844   application.SendNotification();
5845   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5846
5847   // We did expect the animation to finish
5848   application.SendNotification();
5849   finishCheck.CheckSignalReceived();
5850   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
5851   END_TEST;
5852 }
5853
5854 int UtcDaliAnimationAnimateToVector3AlphaFunctionP(void)
5855 {
5856   TestApplication application;
5857
5858   Actor actor = Actor::New();
5859
5860   // Register a Vector3 property
5861   Vector3 startValue(1000.0f, 1000.0f, 1000.0f);
5862   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5863   Stage::GetCurrent().Add(actor);
5864   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
5865   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
5866
5867   // Build the animation
5868   float durationSeconds(1.0f);
5869   Animation animation = Animation::New(durationSeconds);
5870   Vector3 targetValue(9000.0f, 9000.0f, 9000.0f);
5871   Vector3 relativeValue(targetValue - startValue);
5872   animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
5873
5874   Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
5875
5876   // Start the animation
5877   animation.Play();
5878
5879   bool signalReceived(false);
5880   AnimationFinishCheck finishCheck(signalReceived);
5881   animation.FinishedSignal().Connect(&application, finishCheck);
5882
5883   application.SendNotification();
5884   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
5885
5886   // We didn't expect the animation to finish yet
5887   application.SendNotification();
5888   finishCheck.CheckSignalNotReceived();
5889
5890   // The position should have moved more, than with a linear alpha function
5891   Vector3 current( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ) );
5892   DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
5893   DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
5894   DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
5895
5896   application.SendNotification();
5897   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
5898
5899   // We did expect the animation to finish
5900   application.SendNotification();
5901   finishCheck.CheckSignalReceived();
5902   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
5903   END_TEST;
5904 }
5905
5906 int UtcDaliAnimationAnimateToVector3TimePeriodP(void)
5907 {
5908   TestApplication application;
5909
5910   Actor actor = Actor::New();
5911
5912   // Register a Vector3 property
5913   Vector3 startValue(10.0f, 10.0f, 10.0f);
5914   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5915   Stage::GetCurrent().Add(actor);
5916   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
5917   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
5918
5919   // Build the animation
5920   float durationSeconds(1.0f);
5921   Animation animation = Animation::New(durationSeconds);
5922   Vector3 targetValue(-10.0f, 20.0f, 100.0f);
5923   Vector3 relativeValue(targetValue - startValue);
5924   float delay = 0.5f;
5925   animation.AnimateTo(Property(actor, index),
5926                       targetValue,
5927                       TimePeriod(delay, durationSeconds - delay));
5928
5929   // Start the animation
5930   animation.Play();
5931
5932   bool signalReceived(false);
5933   AnimationFinishCheck finishCheck(signalReceived);
5934   animation.FinishedSignal().Connect(&application, finishCheck);
5935
5936   application.SendNotification();
5937   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5938
5939   // We didn't expect the animation to finish yet
5940   application.SendNotification();
5941   finishCheck.CheckSignalNotReceived();
5942   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
5943
5944   application.SendNotification();
5945   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
5946
5947   // We didn't expect the animation to finish yet
5948   application.SendNotification();
5949   finishCheck.CheckSignalNotReceived();
5950   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
5951
5952   application.SendNotification();
5953   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
5954
5955   // We did expect the animation to finish
5956   application.SendNotification();
5957   finishCheck.CheckSignalReceived();
5958   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
5959   END_TEST;
5960 }
5961
5962 int UtcDaliAnimationAnimateToVector3AlphaFunctionTimePeriodP(void)
5963 {
5964   TestApplication application;
5965
5966   Actor actor = Actor::New();
5967
5968   // Register a Vector3 property
5969   Vector3 startValue(10.0f, 10.0f, 10.0f);
5970   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
5971   Stage::GetCurrent().Add(actor);
5972   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
5973   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
5974
5975   // Build the animation
5976   float durationSeconds(1.0f);
5977   Animation animation = Animation::New(durationSeconds);
5978   Vector3 targetValue(30.0f, 30.0f, 30.0f);
5979   Vector3 relativeValue(targetValue - startValue);
5980   float delay = 0.5f;
5981   animation.AnimateTo(Property(actor, "testProperty"),
5982                       targetValue,
5983                       AlphaFunction::LINEAR,
5984                       TimePeriod(delay, durationSeconds - delay));
5985
5986   // Start the animation
5987   animation.Play();
5988
5989   bool signalReceived(false);
5990   AnimationFinishCheck finishCheck(signalReceived);
5991   animation.FinishedSignal().Connect(&application, finishCheck);
5992
5993   application.SendNotification();
5994   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
5995
5996   // We didn't expect the animation to finish yet
5997   application.SendNotification();
5998   finishCheck.CheckSignalNotReceived();
5999   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
6000
6001   application.SendNotification();
6002   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
6003
6004   // We didn't expect the animation to finish yet
6005   application.SendNotification();
6006   finishCheck.CheckSignalNotReceived();
6007   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
6008
6009   application.SendNotification();
6010   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
6011
6012   // We did expect the animation to finish
6013   application.SendNotification();
6014   finishCheck.CheckSignalReceived();
6015   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
6016   END_TEST;
6017 }
6018
6019 int UtcDaliAnimationAnimateToVector3ComponentP(void)
6020 {
6021   TestApplication application;
6022
6023   Actor actor = Actor::New();
6024
6025   // Register a Vector3 property
6026   Vector3 startValue(10.0f, 10.0f, 10.0f);
6027   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
6028   Stage::GetCurrent().Add(actor);
6029   DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
6030   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
6031
6032   // Build the animation
6033   float durationSeconds(1.0f);
6034   Animation animation = Animation::New(durationSeconds);
6035   Vector3 targetValue(30.0f, 30.0f, 10.0f);
6036   Vector3 relativeValue(targetValue - startValue);
6037   float delay = 0.5f;
6038   animation.AnimateTo(Property(actor, "testProperty",  0),
6039                       30.0f,
6040                       AlphaFunction::LINEAR,
6041                       TimePeriod(delay, durationSeconds - delay));
6042   animation.AnimateTo(Property(actor, index, 1),
6043                       30.0f,
6044                       AlphaFunction::LINEAR,
6045                       TimePeriod(delay, durationSeconds - delay));
6046
6047   // Start the animation
6048   animation.Play();
6049
6050   bool signalReceived(false);
6051   AnimationFinishCheck finishCheck(signalReceived);
6052   animation.FinishedSignal().Connect(&application, finishCheck);
6053
6054   application.SendNotification();
6055   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
6056
6057   // We didn't expect the animation to finish yet
6058   application.SendNotification();
6059   finishCheck.CheckSignalNotReceived();
6060   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue, TEST_LOCATION );
6061
6062   application.SendNotification();
6063   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
6064
6065   // We didn't expect the animation to finish yet
6066   application.SendNotification();
6067   finishCheck.CheckSignalNotReceived();
6068   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
6069
6070   application.SendNotification();
6071   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
6072
6073   // We did expect the animation to finish
6074   application.SendNotification();
6075   finishCheck.CheckSignalReceived();
6076   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector3 >( actor, index ), targetValue, TEST_LOCATION );
6077   END_TEST;
6078 }
6079
6080 int UtcDaliAnimationAnimateToVector4P(void)
6081 {
6082   TestApplication application;
6083
6084   Actor actor = Actor::New();
6085
6086   // Register a Vector4 property
6087   Vector4 startValue(-50.0f, -40.0f, -30.0f, -20.0f);
6088   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
6089   Stage::GetCurrent().Add(actor);
6090   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
6091   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
6092
6093   // Build the animation
6094   float durationSeconds(2.0f);
6095   Animation animation = Animation::New(durationSeconds);
6096   Vector4 targetValue(50.0f, 50.0f, 50.0f, 50.0f);
6097   Vector4 relativeValue(targetValue - startValue);
6098   animation.AnimateTo(Property(actor, index), targetValue);
6099
6100   Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
6101
6102   // Start the animation
6103   animation.Play();
6104
6105   bool signalReceived(false);
6106   AnimationFinishCheck finishCheck(signalReceived);
6107   animation.FinishedSignal().Connect(&application, finishCheck);
6108
6109   application.SendNotification();
6110   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
6111
6112   // We didn't expect the animation to finish yet
6113   application.SendNotification();
6114   finishCheck.CheckSignalNotReceived();
6115   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), ninetyFivePercentProgress, TEST_LOCATION );
6116
6117   application.SendNotification();
6118   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
6119
6120   // We did expect the animation to finish
6121   application.SendNotification();
6122   finishCheck.CheckSignalReceived();
6123   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
6124   END_TEST;
6125 }
6126
6127 int UtcDaliAnimationAnimateToVector4AlphaFunctionP(void)
6128 {
6129   TestApplication application;
6130
6131   Actor actor = Actor::New();
6132
6133   // Register a Vector4 property
6134   Vector4 startValue(1000.0f, 1000.0f, 1000.0f, 1000.0f);
6135   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
6136   Stage::GetCurrent().Add(actor);
6137   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
6138   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
6139
6140   // Build the animation
6141   float durationSeconds(1.0f);
6142   Animation animation = Animation::New(durationSeconds);
6143   Vector4 targetValue(9000.0f, 9000.0f, 9000.0f, 9000.0f);
6144   Vector4 relativeValue(targetValue - startValue);
6145   animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
6146
6147   Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
6148
6149   // Start the animation
6150   animation.Play();
6151
6152   bool signalReceived(false);
6153   AnimationFinishCheck finishCheck(signalReceived);
6154   animation.FinishedSignal().Connect(&application, finishCheck);
6155
6156   application.SendNotification();
6157   application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
6158
6159   // We didn't expect the animation to finish yet
6160   application.SendNotification();
6161   finishCheck.CheckSignalNotReceived();
6162
6163   // The position should have moved more, than with a linear alpha function
6164   Vector4 current( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ) );
6165   DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
6166   DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
6167   DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
6168   DALI_TEST_CHECK( current.w > ninetyFivePercentProgress.w );
6169
6170   application.SendNotification();
6171   application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
6172
6173   // We did expect the animation to finish
6174   application.SendNotification();
6175   finishCheck.CheckSignalReceived();
6176   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
6177   END_TEST;
6178 }
6179
6180 int UtcDaliAnimationAnimateToVector4TimePeriodP(void)
6181 {
6182   TestApplication application;
6183
6184   Actor actor = Actor::New();
6185
6186   // Register a Vector4 property
6187   Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
6188   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
6189   Stage::GetCurrent().Add(actor);
6190   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
6191   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, VECTOR4_EPSILON, TEST_LOCATION );
6192
6193   // Build the animation
6194   float durationSeconds(1.0f);
6195   Animation animation = Animation::New(durationSeconds);
6196   Vector4 targetValue(-10.0f, 20.0f, 100.0f, 100.0f);
6197   Vector4 relativeValue(targetValue - startValue);
6198   float delay = 0.5f;
6199   animation.AnimateTo(Property(actor, index),
6200                       targetValue,
6201                       TimePeriod(delay, durationSeconds - delay));
6202
6203   // Start the animation
6204   animation.Play();
6205
6206   bool signalReceived(false);
6207   AnimationFinishCheck finishCheck(signalReceived);
6208   animation.FinishedSignal().Connect(&application, finishCheck);
6209
6210   application.SendNotification();
6211   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
6212
6213   // We didn't expect the animation to finish yet
6214   application.SendNotification();
6215   finishCheck.CheckSignalNotReceived();
6216   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, VECTOR4_EPSILON, TEST_LOCATION );
6217
6218   application.SendNotification();
6219   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
6220
6221   // We didn't expect the animation to finish yet
6222   application.SendNotification();
6223   finishCheck.CheckSignalNotReceived();
6224   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue+(relativeValue*0.5f), VECTOR4_EPSILON, TEST_LOCATION );
6225
6226   application.SendNotification();
6227   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
6228
6229   // We did expect the animation to finish
6230   application.SendNotification();
6231   finishCheck.CheckSignalReceived();
6232   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, VECTOR4_EPSILON, TEST_LOCATION );
6233   END_TEST;
6234 }
6235
6236 int UtcDaliAnimationAnimateToVector4AlphaFunctionTimePeriodP(void)
6237 {
6238   TestApplication application;
6239
6240   Actor actor = Actor::New();
6241
6242   // Register a Vector4 property
6243   Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
6244   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
6245   Stage::GetCurrent().Add(actor);
6246   DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
6247   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
6248
6249   // Build the animation
6250   float durationSeconds(1.0f);
6251   Animation animation = Animation::New(durationSeconds);
6252   Vector4 targetValue(30.0f, 30.0f, 30.0f, 30.0f);
6253   Vector4 relativeValue(targetValue - startValue);
6254   float delay = 0.5f;
6255   animation.AnimateTo(Property(actor, index),
6256                       targetValue,
6257                       AlphaFunction::LINEAR,
6258                       TimePeriod(delay, durationSeconds - delay));
6259
6260   // Start the animation
6261   animation.Play();
6262
6263   bool signalReceived(false);
6264   AnimationFinishCheck finishCheck(signalReceived);
6265   animation.FinishedSignal().Connect(&application, finishCheck);
6266
6267   application.SendNotification();
6268   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
6269
6270   // We didn't expect the animation to finish yet
6271   application.SendNotification();
6272   finishCheck.CheckSignalNotReceived();
6273   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue, TEST_LOCATION );
6274
6275   application.SendNotification();
6276   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
6277
6278   // We didn't expect the animation to finish yet
6279   application.SendNotification();
6280   finishCheck.CheckSignalNotReceived();
6281   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
6282
6283   application.SendNotification();
6284   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
6285
6286   // We did expect the animation to finish
6287   application.SendNotification();
6288   finishCheck.CheckSignalReceived();
6289   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< Vector4 >( actor, index ), targetValue, TEST_LOCATION );
6290   END_TEST;
6291 }
6292
6293 int UtcDaliAnimationAnimateToActorParentOriginP(void)
6294 {
6295   TestApplication application;
6296
6297   Actor actor = Actor::New();
6298   Stage::GetCurrent().Add(actor);
6299   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin(), ParentOrigin::TOP_LEFT, TEST_LOCATION );
6300
6301   // Build the animation
6302   float durationSeconds(1.0f);
6303   Animation animation = Animation::New(durationSeconds);
6304   Vector3 targetParentOrigin(ParentOrigin::BOTTOM_RIGHT);
6305
6306   try
6307   {
6308     animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN), targetParentOrigin );
6309   }
6310   catch (Dali::DaliException& e)
6311   {
6312     DALI_TEST_PRINT_ASSERT( e );
6313     DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6314   }
6315   END_TEST;
6316 }
6317
6318 int UtcDaliAnimationAnimateToActorParentOriginXP(void)
6319 {
6320   TestApplication application;
6321
6322   Actor actor = Actor::New();
6323   Stage::GetCurrent().Add(actor);
6324   float startValue(0.0f);
6325   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin().x, startValue, TEST_LOCATION );
6326   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_X), startValue, TEST_LOCATION );
6327
6328   // Build the animation
6329   float durationSeconds(1.0f);
6330   Animation animation = Animation::New(durationSeconds);
6331   float targetX(1.0f);
6332
6333   try
6334   {
6335     animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_X), targetX );
6336   }
6337   catch (Dali::DaliException& e)
6338   {
6339     DALI_TEST_PRINT_ASSERT( e );
6340     DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6341   }
6342   END_TEST;
6343 }
6344
6345 int UtcDaliAnimationAnimateToActorParentOriginYP(void)
6346 {
6347   TestApplication application;
6348
6349   Actor actor = Actor::New();
6350   Stage::GetCurrent().Add(actor);
6351   float startValue(0.0f);
6352   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin().y, startValue, TEST_LOCATION );
6353   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_Y), startValue, TEST_LOCATION );
6354
6355   // Build the animation
6356   float durationSeconds(1.0f);
6357   Animation animation = Animation::New(durationSeconds);
6358   float targetY(1.0f);
6359
6360   try
6361   {
6362     animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_Y), targetY );
6363   }
6364   catch (Dali::DaliException& e)
6365   {
6366     DALI_TEST_PRINT_ASSERT( e );
6367     DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6368   }
6369   END_TEST;
6370 }
6371
6372 int UtcDaliAnimationAnimateToActorParentOriginZP(void)
6373 {
6374   TestApplication application;
6375
6376   Actor actor = Actor::New();
6377   Stage::GetCurrent().Add(actor);
6378   float startValue(0.5f);
6379   DALI_TEST_EQUALS( actor.GetCurrentParentOrigin().z, startValue, TEST_LOCATION );
6380   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_Z), startValue, TEST_LOCATION );
6381
6382   // Build the animation
6383   float durationSeconds(1.0f);
6384   Animation animation = Animation::New(durationSeconds);
6385   float targetZ(1.0f);
6386
6387   try
6388   {
6389     animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_Z), targetZ );
6390   }
6391   catch (Dali::DaliException& e)
6392   {
6393     DALI_TEST_PRINT_ASSERT( e );
6394     DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6395   }
6396   END_TEST;
6397 }
6398
6399 int UtcDaliAnimationAnimateToActorAnchorPointP(void)
6400 {
6401   TestApplication application;
6402
6403   Actor actor = Actor::New();
6404   Stage::GetCurrent().Add(actor);
6405   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint(), AnchorPoint::CENTER, TEST_LOCATION );
6406
6407   // Build the animation
6408   float durationSeconds(1.0f);
6409   Animation animation = Animation::New(durationSeconds);
6410   Vector3 targetAnchorPoint(AnchorPoint::TOP_LEFT);
6411
6412   try
6413   {
6414     animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT), targetAnchorPoint);
6415   }
6416   catch (Dali::DaliException& e)
6417   {
6418     DALI_TEST_PRINT_ASSERT( e );
6419     DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6420   }
6421   END_TEST;
6422 }
6423
6424 int UtcDaliAnimationAnimateToActorAnchorPointXP(void)
6425 {
6426   TestApplication application;
6427
6428   Actor actor = Actor::New();
6429   Stage::GetCurrent().Add(actor);
6430   float startValue(0.5f);
6431   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint().x, startValue, TEST_LOCATION );
6432   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_X), startValue, TEST_LOCATION );
6433
6434   // Build the animation
6435   float durationSeconds(1.0f);
6436   Animation animation = Animation::New(durationSeconds);
6437   float targetX(1.0f);
6438
6439   try
6440   {
6441     animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_X), targetX );
6442   }
6443   catch (Dali::DaliException& e)
6444   {
6445     DALI_TEST_PRINT_ASSERT( e );
6446     DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6447   }
6448   END_TEST;
6449 }
6450
6451 int UtcDaliAnimationAnimateToActorAnchorPointYP(void)
6452 {
6453   TestApplication application;
6454
6455   Actor actor = Actor::New();
6456   Stage::GetCurrent().Add(actor);
6457   float startValue(0.5f);
6458   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint().y, startValue, TEST_LOCATION );
6459   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_Y), startValue, TEST_LOCATION );
6460
6461   // Build the animation
6462   float durationSeconds(1.0f);
6463   Animation animation = Animation::New(durationSeconds);
6464   float targetY(0.0f);
6465
6466   try
6467   {
6468     animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_Y), targetY );
6469   }
6470   catch (Dali::DaliException& e)
6471   {
6472     DALI_TEST_PRINT_ASSERT( e );
6473     DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6474   }
6475   END_TEST;
6476 }
6477
6478 int UtcDaliAnimationAnimateToActorAnchorPointZP(void)
6479 {
6480   TestApplication application;
6481
6482   Actor actor = Actor::New();
6483   Stage::GetCurrent().Add(actor);
6484   float startValue(0.5f);
6485   DALI_TEST_EQUALS( actor.GetCurrentAnchorPoint().z, startValue, TEST_LOCATION );
6486   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_Z), startValue, TEST_LOCATION );
6487
6488   // Build the animation
6489   float durationSeconds(1.0f);
6490   Animation animation = Animation::New(durationSeconds);
6491   float targetZ(100.0f);
6492
6493   try
6494   {
6495     animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_Z), targetZ );
6496   }
6497   catch (Dali::DaliException& e)
6498   {
6499     DALI_TEST_PRINT_ASSERT( e );
6500     DALI_TEST_ASSERT(e, "IsPropertyAnimatable( index )", TEST_LOCATION);
6501   }
6502   END_TEST;
6503 }
6504
6505 int UtcDaliAnimationAnimateToActorSizeP(void)
6506 {
6507   TestApplication application;
6508
6509   Actor actor = Actor::New();
6510   Stage::GetCurrent().Add(actor);
6511   DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6512
6513   // Build the animation
6514   float durationSeconds(1.0f);
6515   Animation animation = Animation::New(durationSeconds);
6516   Vector3 targetSize(100.0f, 100.0f, 100.0f);
6517   animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize );
6518
6519   Vector3 ninetyNinePercentProgress(targetSize * 0.99f);
6520
6521   // Start the animation
6522   animation.Play();
6523
6524   bool signalReceived(false);
6525   AnimationFinishCheck finishCheck(signalReceived);
6526   animation.FinishedSignal().Connect(&application, finishCheck);
6527
6528   application.SendNotification();
6529   application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
6530
6531   // We didn't expect the animation to finish yet
6532   application.SendNotification();
6533   finishCheck.CheckSignalNotReceived();
6534   DALI_TEST_EQUALS( actor.GetCurrentSize(), ninetyNinePercentProgress, TEST_LOCATION );
6535
6536   application.SendNotification();
6537   application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
6538
6539   // We did expect the animation to finish
6540   application.SendNotification();
6541   finishCheck.CheckSignalReceived();
6542   DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
6543
6544   // Reset everything
6545   finishCheck.Reset();
6546   actor.SetSize(Vector3::ZERO);
6547   application.SendNotification();
6548   application.Render(0);
6549   DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6550
6551   // Repeat with a different (ease-in) alpha function
6552   animation = Animation::New(durationSeconds);
6553   animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::EASE_IN);
6554   animation.FinishedSignal().Connect(&application, finishCheck);
6555   animation.Play();
6556
6557   application.SendNotification();
6558   application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
6559
6560   // We didn't expect the animation to finish yet
6561   application.SendNotification();
6562   finishCheck.CheckSignalNotReceived();
6563
6564   // The size should have travelled less, than with a linear alpha function
6565   Vector3 current(actor.GetCurrentSize());
6566   DALI_TEST_CHECK( current.x > 0.0f );
6567   DALI_TEST_CHECK( current.y > 0.0f );
6568   DALI_TEST_CHECK( current.z > 0.0f );
6569   DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
6570   DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
6571   DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
6572
6573   application.SendNotification();
6574   application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
6575
6576   // We did expect the animation to finish
6577   application.SendNotification();
6578   finishCheck.CheckSignalReceived();
6579   DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
6580
6581   // Reset everything
6582   finishCheck.Reset();
6583   actor.SetSize(Vector3::ZERO);
6584   application.SendNotification();
6585   application.Render(0);
6586   DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6587
6588   // Repeat with a delay
6589   float delay = 0.5f;
6590   animation = Animation::New(durationSeconds);
6591   animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
6592   animation.FinishedSignal().Connect(&application, finishCheck);
6593   animation.Play();
6594
6595   application.SendNotification();
6596   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
6597
6598   // We didn't expect the animation to finish yet
6599   application.SendNotification();
6600   finishCheck.CheckSignalNotReceived();
6601   DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6602
6603   application.SendNotification();
6604   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6605
6606   // We did expect the animation to finish
6607   application.SendNotification();
6608   finishCheck.CheckSignalReceived();
6609   DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
6610   END_TEST;
6611 }
6612
6613 int UtcDaliAnimationAnimateToActorSizeWidthP(void)
6614 {
6615   TestApplication application;
6616
6617   Actor actor = Actor::New();
6618   Stage::GetCurrent().Add(actor);
6619   float startValue(0.0f);
6620   DALI_TEST_EQUALS( actor.GetCurrentSize().width, startValue, TEST_LOCATION );
6621   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), startValue, TEST_LOCATION );
6622
6623   // Build the animation
6624   float durationSeconds(1.0f);
6625   Animation animation = Animation::New(durationSeconds);
6626   float targetWidth(10.0f);
6627   animation.AnimateTo( Property(actor, Actor::Property::SIZE_WIDTH), targetWidth );
6628
6629   float fiftyPercentProgress(startValue + (targetWidth - startValue)*0.5f);
6630
6631   // Start the animation
6632   animation.Play();
6633
6634   bool signalReceived(false);
6635   AnimationFinishCheck finishCheck(signalReceived);
6636   animation.FinishedSignal().Connect(&application, finishCheck);
6637
6638   application.SendNotification();
6639   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
6640
6641   // We didn't expect the animation to finish yet
6642   application.SendNotification();
6643   finishCheck.CheckSignalNotReceived();
6644   DALI_TEST_EQUALS( actor.GetCurrentSize().width, fiftyPercentProgress, TEST_LOCATION );
6645
6646   application.SendNotification();
6647   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6648
6649   // We did expect the animation to finish
6650   application.SendNotification();
6651   finishCheck.CheckSignalReceived();
6652   DALI_TEST_EQUALS( actor.GetCurrentSize().width, targetWidth, TEST_LOCATION );
6653   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetWidth, TEST_LOCATION );
6654   END_TEST;
6655 }
6656
6657 int UtcDaliAnimationAnimateToActorSizeHeightP(void)
6658 {
6659   TestApplication application;
6660
6661   Actor actor = Actor::New();
6662   Stage::GetCurrent().Add(actor);
6663   float startValue(0.0f);
6664   DALI_TEST_EQUALS( actor.GetCurrentSize().height, startValue, TEST_LOCATION );
6665   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), startValue, TEST_LOCATION );
6666
6667   // Build the animation
6668   float durationSeconds(1.0f);
6669   Animation animation = Animation::New(durationSeconds);
6670   float targetHeight(-10.0f);
6671   animation.AnimateTo( Property(actor, Actor::Property::SIZE_HEIGHT), targetHeight );
6672
6673   float fiftyPercentProgress(startValue + (targetHeight - startValue)*0.5f);
6674
6675   // Start the animation
6676   animation.Play();
6677
6678   bool signalReceived(false);
6679   AnimationFinishCheck finishCheck(signalReceived);
6680   animation.FinishedSignal().Connect(&application, finishCheck);
6681
6682   application.SendNotification();
6683   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
6684
6685   // We didn't expect the animation to finish yet
6686   application.SendNotification();
6687   finishCheck.CheckSignalNotReceived();
6688   DALI_TEST_EQUALS( actor.GetCurrentSize().height, fiftyPercentProgress, TEST_LOCATION );
6689
6690   application.SendNotification();
6691   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6692
6693   // We did expect the animation to finish
6694   application.SendNotification();
6695   finishCheck.CheckSignalReceived();
6696   DALI_TEST_EQUALS( actor.GetCurrentSize().height, targetHeight, TEST_LOCATION );
6697   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetHeight, TEST_LOCATION );
6698   END_TEST;
6699 }
6700
6701 int UtcDaliAnimationAnimateToActorSizeDepthP(void)
6702 {
6703   TestApplication application;
6704
6705   Actor actor = Actor::New();
6706   Stage::GetCurrent().Add(actor);
6707   float startValue(0.0f);
6708   DALI_TEST_EQUALS( actor.GetCurrentSize().depth, startValue, TEST_LOCATION );
6709   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), startValue, TEST_LOCATION );
6710
6711   // Build the animation
6712   float durationSeconds(1.0f);
6713   Animation animation = Animation::New(durationSeconds);
6714   float targetDepth(-10.0f);
6715   animation.AnimateTo( Property(actor, Actor::Property::SIZE_DEPTH), targetDepth );
6716
6717   float fiftyPercentProgress(startValue + (targetDepth - startValue)*0.5f);
6718
6719   // Start the animation
6720   animation.Play();
6721
6722   bool signalReceived(false);
6723   AnimationFinishCheck finishCheck(signalReceived);
6724   animation.FinishedSignal().Connect(&application, finishCheck);
6725
6726   application.SendNotification();
6727   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
6728
6729   // We didn't expect the animation to finish yet
6730   application.SendNotification();
6731   finishCheck.CheckSignalNotReceived();
6732   DALI_TEST_EQUALS( actor.GetCurrentSize().depth, fiftyPercentProgress, TEST_LOCATION );
6733
6734   application.SendNotification();
6735   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6736
6737   // We did expect the animation to finish
6738   application.SendNotification();
6739   finishCheck.CheckSignalReceived();
6740   DALI_TEST_EQUALS( actor.GetCurrentSize().depth, targetDepth, TEST_LOCATION );
6741   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetDepth, TEST_LOCATION );
6742   END_TEST;
6743 }
6744
6745 int UtcDaliAnimationAnimateToActorSizeWidthHeightP(void)
6746 {
6747   TestApplication application;
6748
6749   Actor actor = Actor::New();
6750   Stage::GetCurrent().Add(actor);
6751   DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6752
6753   // Build the animation
6754   float durationSeconds(1.0f);
6755   Animation animation = Animation::New(durationSeconds);
6756   Vector3 targetSize(100.0f, 100.0f, 100.0f);
6757   animation.AnimateTo( Property( actor, Actor::Property::SIZE ), targetSize );
6758
6759   Vector3 ninetyNinePercentProgress(targetSize * 0.99f);
6760
6761   // Start the animation
6762   animation.Play();
6763
6764   bool signalReceived(false);
6765   AnimationFinishCheck finishCheck(signalReceived);
6766   animation.FinishedSignal().Connect(&application, finishCheck);
6767
6768   application.SendNotification();
6769   application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
6770
6771   // We didn't expect the animation to finish yet
6772   application.SendNotification();
6773   finishCheck.CheckSignalNotReceived();
6774   DALI_TEST_EQUALS( actor.GetCurrentSize(), ninetyNinePercentProgress, TEST_LOCATION );
6775
6776   application.SendNotification();
6777   application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
6778
6779   // We did expect the animation to finish
6780   application.SendNotification();
6781   finishCheck.CheckSignalReceived();
6782   DALI_TEST_EQUALS( actor.GetCurrentSize(), targetSize, TEST_LOCATION );
6783
6784   // Reset everything
6785   finishCheck.Reset();
6786   actor.SetSize(Vector3::ZERO);
6787   application.SendNotification();
6788   application.Render(0);
6789   DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6790
6791   // Repeat with a different (ease-in) alpha function
6792   animation = Animation::New(durationSeconds);
6793   animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunction::EASE_IN );
6794   animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunction::EASE_IN );
6795   animation.FinishedSignal().Connect(&application, finishCheck);
6796   animation.Play();
6797
6798   application.SendNotification();
6799   application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
6800
6801   // We didn't expect the animation to finish yet
6802   application.SendNotification();
6803   finishCheck.CheckSignalNotReceived();
6804
6805   // The size should have travelled less, than with a linear alpha function
6806   Vector3 current(actor.GetCurrentSize());
6807   DALI_TEST_CHECK( current.x > 0.0f );
6808   DALI_TEST_CHECK( current.y > 0.0f );
6809   DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
6810   DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
6811
6812   application.SendNotification();
6813   application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
6814
6815   // We did expect the animation to finish
6816   application.SendNotification();
6817   finishCheck.CheckSignalReceived();
6818   DALI_TEST_EQUALS( actor.GetCurrentSize().x, targetSize.x, TEST_LOCATION );
6819   DALI_TEST_EQUALS( actor.GetCurrentSize().y, targetSize.y, TEST_LOCATION );
6820
6821   // Reset everything
6822   finishCheck.Reset();
6823   actor.SetSize(Vector3::ZERO);
6824   application.SendNotification();
6825   application.Render(0);
6826   DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6827
6828   // Repeat with a delay
6829   float delay = 0.5f;
6830   animation = Animation::New(durationSeconds);
6831   animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
6832   animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
6833   animation.FinishedSignal().Connect(&application, finishCheck);
6834   animation.Play();
6835
6836   application.SendNotification();
6837   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
6838
6839   // We didn't expect the animation to finish yet
6840   application.SendNotification();
6841   finishCheck.CheckSignalNotReceived();
6842   DALI_TEST_EQUALS( actor.GetCurrentSize(), Vector3::ZERO, TEST_LOCATION );
6843
6844   application.SendNotification();
6845   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6846
6847   // We did expect the animation to finish
6848   application.SendNotification();
6849   finishCheck.CheckSignalReceived();
6850   DALI_TEST_EQUALS( actor.GetCurrentSize().x, targetSize.x, TEST_LOCATION );
6851   DALI_TEST_EQUALS( actor.GetCurrentSize().y, targetSize.y, TEST_LOCATION );
6852   END_TEST;
6853 }
6854
6855 int UtcDaliAnimationAnimateToActorPositionP(void)
6856 {
6857   TestApplication application;
6858
6859   Actor actor = Actor::New();
6860   Stage::GetCurrent().Add(actor);
6861   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
6862
6863   // Build the animation
6864   float durationSeconds(1.0f);
6865   Animation animation = Animation::New(durationSeconds);
6866   Vector3 targetPosition(200.0f, 200.0f, 200.0f);
6867   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
6868
6869   Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
6870
6871   // Start the animation
6872   animation.Play();
6873
6874   bool signalReceived(false);
6875   AnimationFinishCheck finishCheck(signalReceived);
6876   animation.FinishedSignal().Connect(&application, finishCheck);
6877
6878   application.SendNotification();
6879   application.Render(static_cast<unsigned int>(durationSeconds*750.0f)/* 75% progress */);
6880
6881   // We didn't expect the animation to finish yet
6882   application.SendNotification();
6883   finishCheck.CheckSignalNotReceived();
6884   DALI_TEST_EQUALS( actor.GetCurrentPosition(), seventyFivePercentProgress, TEST_LOCATION );
6885
6886   application.SendNotification();
6887   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
6888
6889   // We did expect the animation to finish
6890   application.SendNotification();
6891   finishCheck.CheckSignalReceived();
6892   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
6893   END_TEST;
6894 }
6895
6896 int UtcDaliAnimationAnimateToActorPositionXP(void)
6897 {
6898   TestApplication application;
6899
6900   Actor actor = Actor::New();
6901   Stage::GetCurrent().Add(actor);
6902   float startValue(0.0f);
6903   DALI_TEST_EQUALS( actor.GetCurrentPosition().x, startValue, TEST_LOCATION );
6904   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
6905   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
6906   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
6907
6908   // Build the animation
6909   float durationSeconds(1.0f);
6910   Animation animation = Animation::New(durationSeconds);
6911   float targetX(1.0f);
6912   animation.AnimateTo( Property(actor, Actor::Property::POSITION_X), targetX );
6913
6914   float fiftyPercentProgress(startValue + (targetX - startValue)*0.5f);
6915
6916   // Start the animation
6917   animation.Play();
6918
6919   bool signalReceived(false);
6920   AnimationFinishCheck finishCheck(signalReceived);
6921   animation.FinishedSignal().Connect(&application, finishCheck);
6922
6923   application.SendNotification();
6924   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
6925
6926   // We didn't expect the animation to finish yet
6927   application.SendNotification();
6928   finishCheck.CheckSignalNotReceived();
6929   DALI_TEST_EQUALS( actor.GetCurrentPosition().x, fiftyPercentProgress, TEST_LOCATION );
6930
6931   application.SendNotification();
6932   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6933
6934   // We did expect the animation to finish
6935   application.SendNotification();
6936   finishCheck.CheckSignalReceived();
6937   DALI_TEST_EQUALS( actor.GetCurrentPosition().x, targetX, TEST_LOCATION );
6938   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetX, TEST_LOCATION );
6939   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
6940   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
6941   END_TEST;
6942 }
6943
6944 int UtcDaliAnimationAnimateToActorPositionYP(void)
6945 {
6946   TestApplication application;
6947
6948   Actor actor = Actor::New();
6949   Stage::GetCurrent().Add(actor);
6950   float startValue(0.0f);
6951   DALI_TEST_EQUALS( actor.GetCurrentPosition().y, startValue, TEST_LOCATION );
6952   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
6953   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
6954   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
6955
6956   // Build the animation
6957   float durationSeconds(1.0f);
6958   Animation animation = Animation::New(durationSeconds);
6959   float targetY(10.0f);
6960   animation.AnimateTo( Property(actor, Actor::Property::POSITION_Y), targetY );
6961
6962   float fiftyPercentProgress(startValue + (targetY - startValue)*0.5f);
6963
6964   // Start the animation
6965   animation.Play();
6966
6967   bool signalReceived(false);
6968   AnimationFinishCheck finishCheck(signalReceived);
6969   animation.FinishedSignal().Connect(&application, finishCheck);
6970
6971   application.SendNotification();
6972   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
6973
6974   // We didn't expect the animation to finish yet
6975   application.SendNotification();
6976   finishCheck.CheckSignalNotReceived();
6977   DALI_TEST_EQUALS( actor.GetCurrentPosition().y, fiftyPercentProgress, TEST_LOCATION );
6978
6979   application.SendNotification();
6980   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
6981
6982   // We did expect the animation to finish
6983   application.SendNotification();
6984   finishCheck.CheckSignalReceived();
6985   DALI_TEST_EQUALS( actor.GetCurrentPosition().y, targetY, TEST_LOCATION );
6986   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
6987   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetY, TEST_LOCATION );
6988   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
6989   END_TEST;
6990 }
6991
6992 int UtcDaliAnimationAnimateToActorPositionZP(void)
6993 {
6994   TestApplication application;
6995
6996   Actor actor = Actor::New();
6997   Stage::GetCurrent().Add(actor);
6998   float startValue(0.0f);
6999   DALI_TEST_EQUALS( actor.GetCurrentPosition().z, startValue, TEST_LOCATION );
7000   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
7001   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
7002   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
7003
7004   // Build the animation
7005   float durationSeconds(1.0f);
7006   Animation animation = Animation::New(durationSeconds);
7007   float targetZ(-5.0f);
7008   animation.AnimateTo( Property(actor, Actor::Property::POSITION_Z), targetZ );
7009
7010   float fiftyPercentProgress(startValue + (targetZ - startValue)*0.5f);
7011
7012   // Start the animation
7013   animation.Play();
7014
7015   bool signalReceived(false);
7016   AnimationFinishCheck finishCheck(signalReceived);
7017   animation.FinishedSignal().Connect(&application, finishCheck);
7018
7019   application.SendNotification();
7020   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7021
7022   // We didn't expect the animation to finish yet
7023   application.SendNotification();
7024   finishCheck.CheckSignalNotReceived();
7025   DALI_TEST_EQUALS( actor.GetCurrentPosition().z, fiftyPercentProgress, TEST_LOCATION );
7026
7027   application.SendNotification();
7028   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7029
7030   // We did expect the animation to finish
7031   application.SendNotification();
7032   finishCheck.CheckSignalReceived();
7033   DALI_TEST_EQUALS( actor.GetCurrentPosition().z, targetZ, TEST_LOCATION );
7034   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
7035   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
7036   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetZ, TEST_LOCATION );
7037   END_TEST;
7038 }
7039
7040 int UtcDaliAnimationAnimateToActorPositionAlphaFunctionP(void)
7041 {
7042   TestApplication application;
7043
7044   Actor actor = Actor::New();
7045   Stage::GetCurrent().Add(actor);
7046   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
7047
7048   // Build the animation
7049   float durationSeconds(1.0f);
7050   Animation animation = Animation::New(durationSeconds);
7051   Vector3 targetPosition(200.0f, 200.0f, 200.0f);
7052   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::EASE_IN);
7053
7054   Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
7055
7056   // Start the animation
7057   animation.Play();
7058
7059   bool signalReceived(false);
7060   AnimationFinishCheck finishCheck(signalReceived);
7061   animation.FinishedSignal().Connect(&application, finishCheck);
7062
7063   application.SendNotification();
7064   application.Render(static_cast<unsigned int>(durationSeconds*750.0f)/* 75% progress */);
7065
7066   // We didn't expect the animation to finish yet
7067   application.SendNotification();
7068   finishCheck.CheckSignalNotReceived();
7069
7070   // The position should have moved less, than with a linear alpha function
7071   Vector3 current(actor.GetCurrentPosition());
7072   DALI_TEST_CHECK( current.x > Vector3::ZERO.x );
7073   DALI_TEST_CHECK( current.y > Vector3::ZERO.y );
7074   DALI_TEST_CHECK( current.z > Vector3::ZERO.z );
7075   DALI_TEST_CHECK( current.x < seventyFivePercentProgress.x );
7076   DALI_TEST_CHECK( current.y < seventyFivePercentProgress.y );
7077   DALI_TEST_CHECK( current.z < seventyFivePercentProgress.z );
7078
7079   application.SendNotification();
7080   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7081
7082   // We did expect the animation to finish
7083   application.SendNotification();
7084   finishCheck.CheckSignalReceived();
7085   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
7086   END_TEST;
7087 }
7088
7089 int UtcDaliAnimationAnimateToActorPositionTimePeriodP(void)
7090 {
7091   TestApplication application;
7092
7093   Actor actor = Actor::New();
7094   Stage::GetCurrent().Add(actor);
7095   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
7096
7097   // Build the animation
7098   float durationSeconds(1.0f);
7099   Animation animation = Animation::New(durationSeconds);
7100   Vector3 targetPosition(200.0f, 200.0f, 200.0f);
7101   float delay = 0.5f;
7102   animation.AnimateTo( Property(actor, Actor::Property::POSITION),
7103                        targetPosition,
7104                        TimePeriod( delay, durationSeconds - delay ) );
7105
7106   Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
7107
7108   // Start the animation
7109   animation.Play();
7110
7111   bool signalReceived(false);
7112   AnimationFinishCheck finishCheck(signalReceived);
7113   animation.FinishedSignal().Connect(&application, finishCheck);
7114
7115   application.SendNotification();
7116   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
7117
7118   // We didn't expect the animation to finish yet
7119   application.SendNotification();
7120   finishCheck.CheckSignalNotReceived();
7121   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
7122
7123   application.SendNotification();
7124   application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.75)/* 7/8 animation progress, 3/4 animator progress */);
7125
7126   // We didn't expect the animation to finish yet
7127   application.SendNotification();
7128   finishCheck.CheckSignalNotReceived();
7129   DALI_TEST_EQUALS( actor.GetCurrentPosition(), seventyFivePercentProgress, TEST_LOCATION );
7130
7131   application.SendNotification();
7132   application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.25) + 1u/*just beyond the animation duration*/);
7133
7134   // We did expect the animation to finish
7135   application.SendNotification();
7136   finishCheck.CheckSignalReceived();
7137   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
7138   END_TEST;
7139 }
7140
7141 int UtcDaliAnimationAnimateToActorPositionAlphaFunctionTimePeriodP(void)
7142 {
7143   TestApplication application;
7144
7145   Actor actor = Actor::New();
7146   Stage::GetCurrent().Add(actor);
7147   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
7148
7149   // Build the animation
7150   float durationSeconds(1.0f);
7151   Animation animation = Animation::New(durationSeconds);
7152   Vector3 targetPosition(200.0f, 200.0f, 200.0f);
7153   float delay = 0.5f;
7154   animation.AnimateTo( Property(actor, Actor::Property::POSITION),
7155                        targetPosition,
7156                        AlphaFunction::LINEAR,
7157                        TimePeriod( delay, durationSeconds - delay ) );
7158
7159   Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
7160
7161   // Start the animation
7162   animation.Play();
7163
7164   bool signalReceived(false);
7165   AnimationFinishCheck finishCheck(signalReceived);
7166   animation.FinishedSignal().Connect(&application, finishCheck);
7167
7168   application.SendNotification();
7169   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
7170
7171   // We didn't expect the animation to finish yet
7172   application.SendNotification();
7173   finishCheck.CheckSignalNotReceived();
7174   DALI_TEST_EQUALS( actor.GetCurrentPosition(), Vector3::ZERO, TEST_LOCATION );
7175
7176   application.SendNotification();
7177   application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.75)/* 7/8 animation progress, 3/4 animator progress */);
7178
7179   // We didn't expect the animation to finish yet
7180   application.SendNotification();
7181   finishCheck.CheckSignalNotReceived();
7182   DALI_TEST_EQUALS( actor.GetCurrentPosition(), seventyFivePercentProgress, TEST_LOCATION );
7183
7184   application.SendNotification();
7185   application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.25) + 1u/*just beyond the animation duration*/);
7186
7187   // We did expect the animation to finish
7188   application.SendNotification();
7189   finishCheck.CheckSignalReceived();
7190   DALI_TEST_EQUALS( actor.GetCurrentPosition(), targetPosition, TEST_LOCATION );
7191   END_TEST;
7192 }
7193
7194 int UtcDaliAnimationAnimateToActorOrientationAngleAxisP(void)
7195 {
7196   TestApplication application;
7197
7198   Actor actor = Actor::New();
7199   actor.SetOrientation(Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
7200   Stage::GetCurrent().Add(actor);
7201   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
7202
7203   // Build the animation
7204   float durationSeconds(1.0f);
7205   Animation animation = Animation::New(durationSeconds);
7206   Degree targetRotationDegrees(90.0f);
7207   Radian targetRotationRadians(targetRotationDegrees);
7208   animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationRadians, Vector3::YAXIS) );
7209
7210   // Start the animation
7211   animation.Play();
7212
7213   bool signalReceived(false);
7214   AnimationFinishCheck finishCheck(signalReceived);
7215   animation.FinishedSignal().Connect(&application, finishCheck);
7216
7217   application.SendNotification();
7218   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
7219
7220   // We didn't expect the animation to finish yet
7221   application.SendNotification();
7222   finishCheck.CheckSignalNotReceived();
7223   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7224
7225   application.SendNotification();
7226   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
7227
7228   // We didn't expect the animation to finish yet
7229   application.SendNotification();
7230   finishCheck.CheckSignalNotReceived();
7231   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7232
7233   application.SendNotification();
7234   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
7235
7236   // We didn't expect the animation to finish yet
7237   application.SendNotification();
7238   finishCheck.CheckSignalNotReceived();
7239   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7240
7241   application.SendNotification();
7242   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7243
7244   // We did expect the animation to finish
7245   application.SendNotification();
7246   finishCheck.CheckSignalReceived();
7247   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7248   END_TEST;
7249 }
7250
7251 int UtcDaliAnimationAnimateToActorOrientationQuaternionP(void)
7252 {
7253   TestApplication application;
7254
7255   Actor actor = Actor::New();
7256   actor.SetOrientation(Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
7257   Stage::GetCurrent().Add(actor);
7258   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
7259
7260   // Build the animation
7261   float durationSeconds(1.0f);
7262   Animation animation = Animation::New(durationSeconds);
7263   Degree targetRotationDegrees(90.0f);
7264   Radian targetRotationRadians(targetRotationDegrees);
7265   Quaternion targetRotation(targetRotationRadians, Vector3::YAXIS);
7266   animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), targetRotation );
7267
7268   // Start the animation
7269   animation.Play();
7270
7271   bool signalReceived(false);
7272   AnimationFinishCheck finishCheck(signalReceived);
7273   animation.FinishedSignal().Connect(&application, finishCheck);
7274
7275   application.SendNotification();
7276   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
7277
7278   // We didn't expect the animation to finish yet
7279   application.SendNotification();
7280   finishCheck.CheckSignalNotReceived();
7281   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7282
7283   application.SendNotification();
7284   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
7285
7286   // We didn't expect the animation to finish yet
7287   application.SendNotification();
7288   finishCheck.CheckSignalNotReceived();
7289   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7290
7291   application.SendNotification();
7292   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
7293
7294   // We didn't expect the animation to finish yet
7295   application.SendNotification();
7296   finishCheck.CheckSignalNotReceived();
7297   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7298
7299   application.SendNotification();
7300   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7301
7302   // We did expect the animation to finish
7303   application.SendNotification();
7304   finishCheck.CheckSignalReceived();
7305   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7306   END_TEST;
7307 }
7308
7309 int UtcDaliAnimationAnimateToActorOrientationAlphaFunctionP(void)
7310 {
7311   TestApplication application;
7312
7313   Actor actor = Actor::New();
7314   actor.SetOrientation(Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
7315   Stage::GetCurrent().Add(actor);
7316   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(Radian(0.0f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7317
7318   // Build the animation
7319   float durationSeconds(1.0f);
7320   Animation animation = Animation::New(durationSeconds);
7321   Degree targetRotationDegrees(90.0f);
7322   Radian targetRotationRadians(targetRotationDegrees);
7323   animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN);
7324
7325   // Start the animation
7326   animation.Play();
7327
7328   bool signalReceived(false);
7329   AnimationFinishCheck finishCheck(signalReceived);
7330   animation.FinishedSignal().Connect(&application, finishCheck);
7331
7332   application.SendNotification();
7333   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
7334
7335   // We didn't expect the animation to finish yet
7336   application.SendNotification();
7337   finishCheck.CheckSignalNotReceived();
7338   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.25f*0.25f*0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7339
7340   application.SendNotification();
7341   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
7342
7343   // We didn't expect the animation to finish yet
7344   application.SendNotification();
7345   finishCheck.CheckSignalNotReceived();
7346   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.5f*0.5f*0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7347
7348   application.SendNotification();
7349   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
7350
7351   // We didn't expect the animation to finish yet
7352   application.SendNotification();
7353   finishCheck.CheckSignalNotReceived();
7354   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.75f*0.75f*0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7355
7356   application.SendNotification();
7357   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7358
7359   // We did expect the animation to finish
7360   application.SendNotification();
7361   finishCheck.CheckSignalReceived();
7362   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7363   END_TEST;
7364 }
7365
7366 int UtcDaliAnimationAnimateToActorOrientationTimePeriodP(void)
7367 {
7368   TestApplication application;
7369
7370   Actor actor = Actor::New();
7371   actor.SetOrientation(Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
7372   Stage::GetCurrent().Add(actor);
7373   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
7374
7375   // Build the animation
7376   float durationSeconds(1.0f);
7377   Animation animation = Animation::New(durationSeconds);
7378   Degree targetRotationDegrees(90.0f);
7379   Radian targetRotationRadians(targetRotationDegrees);
7380   float delay(0.1f);
7381   animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), TimePeriod(delay, durationSeconds - delay));
7382
7383   // Start the animation
7384   animation.Play();
7385
7386   bool signalReceived(false);
7387   AnimationFinishCheck finishCheck(signalReceived);
7388   animation.FinishedSignal().Connect(&application, finishCheck);
7389
7390   application.SendNotification();
7391   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
7392
7393   // We didn't expect the animation to finish yet
7394   application.SendNotification();
7395   finishCheck.CheckSignalNotReceived();
7396   float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
7397   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7398
7399   application.SendNotification();
7400   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
7401
7402   // We didn't expect the animation to finish yet
7403   application.SendNotification();
7404   finishCheck.CheckSignalNotReceived();
7405   progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
7406   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7407
7408   application.SendNotification();
7409   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
7410
7411   // We didn't expect the animation to finish yet
7412   application.SendNotification();
7413   finishCheck.CheckSignalNotReceived();
7414   progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
7415   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7416
7417   application.SendNotification();
7418   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7419
7420   // We did expect the animation to finish
7421   application.SendNotification();
7422   finishCheck.CheckSignalReceived();
7423   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7424   END_TEST;
7425 }
7426
7427 int UtcDaliAnimationAnimateToActorOrientationAlphaFunctionTimePeriodP(void)
7428 {
7429   TestApplication application;
7430
7431   Actor actor = Actor::New();
7432   actor.SetOrientation(Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
7433   Stage::GetCurrent().Add(actor);
7434   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
7435
7436   // Build the animation
7437   float durationSeconds(1.0f);
7438   Animation animation = Animation::New(durationSeconds);
7439   Degree targetRotationDegrees(90.0f);
7440   Radian targetRotationRadians(targetRotationDegrees);
7441   float delay(0.1f);
7442   animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN, TimePeriod(delay, durationSeconds - delay));
7443
7444   // Start the animation
7445   animation.Play();
7446
7447   bool signalReceived(false);
7448   AnimationFinishCheck finishCheck(signalReceived);
7449   animation.FinishedSignal().Connect(&application, finishCheck);
7450
7451   application.SendNotification();
7452   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
7453
7454   // We didn't expect the animation to finish yet
7455   application.SendNotification();
7456   finishCheck.CheckSignalNotReceived();
7457   float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
7458   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7459
7460   application.SendNotification();
7461   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
7462
7463   // We didn't expect the animation to finish yet
7464   application.SendNotification();
7465   finishCheck.CheckSignalNotReceived();
7466   progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
7467   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7468
7469   application.SendNotification();
7470   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
7471
7472   // We didn't expect the animation to finish yet
7473   application.SendNotification();
7474   finishCheck.CheckSignalNotReceived();
7475   progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
7476   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7477
7478   application.SendNotification();
7479   application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
7480
7481   // We did expect the animation to finish
7482   application.SendNotification();
7483   finishCheck.CheckSignalReceived();
7484   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
7485   END_TEST;
7486 }
7487
7488 int UtcDaliAnimationAnimateToActorScaleP(void)
7489 {
7490   TestApplication application;
7491
7492   Actor actor = Actor::New();
7493   Stage::GetCurrent().Add(actor);
7494   DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
7495
7496   // Build the animation
7497   float durationSeconds(1.0f);
7498   Animation animation = Animation::New(durationSeconds);
7499   Vector3 targetScale(2.0f, 2.0f, 2.0f);
7500   animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale );
7501
7502   Vector3 ninetyNinePercentProgress(Vector3::ONE + (targetScale - Vector3::ONE)*0.99f);
7503
7504   // Start the animation
7505   animation.Play();
7506
7507   bool signalReceived(false);
7508   AnimationFinishCheck finishCheck(signalReceived);
7509   animation.FinishedSignal().Connect(&application, finishCheck);
7510
7511   application.SendNotification();
7512   application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
7513
7514   // We didn't expect the animation to finish yet
7515   application.SendNotification();
7516   finishCheck.CheckSignalNotReceived();
7517   DALI_TEST_EQUALS( actor.GetCurrentScale(), ninetyNinePercentProgress, TEST_LOCATION );
7518
7519   application.SendNotification();
7520   application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
7521
7522   // We did expect the animation to finish
7523   application.SendNotification();
7524   finishCheck.CheckSignalReceived();
7525   DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
7526
7527   // Reset everything
7528   finishCheck.Reset();
7529   actor.SetScale(Vector3::ONE);
7530   application.SendNotification();
7531   application.Render(0);
7532   DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
7533
7534   // Repeat with a different (ease-in) alpha function
7535   animation = Animation::New(durationSeconds);
7536   animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::EASE_IN);
7537   animation.FinishedSignal().Connect(&application, finishCheck);
7538   animation.Play();
7539
7540   application.SendNotification();
7541   application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
7542
7543   // We didn't expect the animation to finish yet
7544   application.SendNotification();
7545   finishCheck.CheckSignalNotReceived();
7546
7547   // The scale should have grown less, than with a linear alpha function
7548   Vector3 current(actor.GetCurrentScale());
7549   DALI_TEST_CHECK( current.x > 1.0f );
7550   DALI_TEST_CHECK( current.y > 1.0f );
7551   DALI_TEST_CHECK( current.z > 1.0f );
7552   DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
7553   DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
7554   DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
7555
7556   application.SendNotification();
7557   application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
7558
7559   // We did expect the animation to finish
7560   application.SendNotification();
7561   finishCheck.CheckSignalReceived();
7562   DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
7563
7564   // Reset everything
7565   finishCheck.Reset();
7566   actor.SetScale(Vector3::ONE);
7567   application.SendNotification();
7568   application.Render(0);
7569   DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
7570
7571   // Repeat with a delay
7572   float delay = 0.5f;
7573   animation = Animation::New(durationSeconds);
7574   animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
7575   animation.FinishedSignal().Connect(&application, finishCheck);
7576   animation.Play();
7577
7578   application.SendNotification();
7579   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
7580
7581   // We didn't expect the animation to finish yet
7582   application.SendNotification();
7583   finishCheck.CheckSignalNotReceived();
7584   DALI_TEST_EQUALS( actor.GetCurrentScale(), Vector3::ONE, TEST_LOCATION );
7585
7586   application.SendNotification();
7587   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7588
7589   // We did expect the animation to finish
7590   application.SendNotification();
7591   finishCheck.CheckSignalReceived();
7592   DALI_TEST_EQUALS( actor.GetCurrentScale(), targetScale, TEST_LOCATION );
7593   END_TEST;
7594 }
7595
7596 int UtcDaliAnimationAnimateToActorScaleXP(void)
7597 {
7598   TestApplication application;
7599
7600   Actor actor = Actor::New();
7601   Stage::GetCurrent().Add(actor);
7602   float startValue(1.0f);
7603   DALI_TEST_EQUALS( actor.GetCurrentScale().x, startValue, TEST_LOCATION );
7604   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7605   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7606   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7607
7608   // Build the animation
7609   float durationSeconds(1.0f);
7610   Animation animation = Animation::New(durationSeconds);
7611   float targetX(10.0f);
7612   animation.AnimateTo( Property(actor, Actor::Property::SCALE_X), targetX );
7613
7614   float fiftyPercentProgress(startValue + (targetX - startValue)*0.5f);
7615
7616   // Start the animation
7617   animation.Play();
7618
7619   bool signalReceived(false);
7620   AnimationFinishCheck finishCheck(signalReceived);
7621   animation.FinishedSignal().Connect(&application, finishCheck);
7622
7623   application.SendNotification();
7624   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7625
7626   // We didn't expect the animation to finish yet
7627   application.SendNotification();
7628   finishCheck.CheckSignalNotReceived();
7629   DALI_TEST_EQUALS( actor.GetCurrentScale().x, fiftyPercentProgress, TEST_LOCATION );
7630   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), fiftyPercentProgress, TEST_LOCATION );
7631   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7632   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7633
7634   application.SendNotification();
7635   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7636
7637   // We did expect the animation to finish
7638   application.SendNotification();
7639   finishCheck.CheckSignalReceived();
7640   DALI_TEST_EQUALS( actor.GetCurrentScale().x, targetX, TEST_LOCATION );
7641   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), targetX, TEST_LOCATION );
7642   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7643   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7644   END_TEST;
7645 }
7646
7647 int UtcDaliAnimationAnimateToActorScaleYP(void)
7648 {
7649   TestApplication application;
7650
7651   Actor actor = Actor::New();
7652   Stage::GetCurrent().Add(actor);
7653   float startValue(1.0f);
7654   DALI_TEST_EQUALS( actor.GetCurrentScale().y, startValue, TEST_LOCATION );
7655   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7656   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7657   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7658
7659   // Build the animation
7660   float durationSeconds(1.0f);
7661   Animation animation = Animation::New(durationSeconds);
7662   float targetY(1000.0f);
7663   animation.AnimateTo( Property(actor, Actor::Property::SCALE_Y), targetY );
7664
7665   float fiftyPercentProgress(startValue + (targetY - startValue)*0.5f);
7666
7667   // Start the animation
7668   animation.Play();
7669
7670   bool signalReceived(false);
7671   AnimationFinishCheck finishCheck(signalReceived);
7672   animation.FinishedSignal().Connect(&application, finishCheck);
7673
7674   application.SendNotification();
7675   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7676
7677   // We didn't expect the animation to finish yet
7678   application.SendNotification();
7679   finishCheck.CheckSignalNotReceived();
7680   DALI_TEST_EQUALS( actor.GetCurrentScale().y, fiftyPercentProgress, TEST_LOCATION );
7681   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7682   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), fiftyPercentProgress, TEST_LOCATION );
7683   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7684
7685   application.SendNotification();
7686   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7687
7688   // We did expect the animation to finish
7689   application.SendNotification();
7690   finishCheck.CheckSignalReceived();
7691   DALI_TEST_EQUALS( actor.GetCurrentScale().y, targetY, TEST_LOCATION );
7692   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7693   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), targetY, TEST_LOCATION );
7694   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7695   END_TEST;
7696 }
7697
7698 int UtcDaliAnimationAnimateToActorScaleZP(void)
7699 {
7700   TestApplication application;
7701
7702   Actor actor = Actor::New();
7703   Stage::GetCurrent().Add(actor);
7704   float startValue(1.0f);
7705   DALI_TEST_EQUALS( actor.GetCurrentScale().z, startValue, TEST_LOCATION );
7706   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7707   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7708   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
7709
7710   // Build the animation
7711   float durationSeconds(1.0f);
7712   Animation animation = Animation::New(durationSeconds);
7713   float targetZ(-1000.0f);
7714   animation.AnimateTo( Property(actor, Actor::Property::SCALE_Z), targetZ );
7715
7716   float fiftyPercentProgress(startValue + (targetZ - startValue)*0.5f);
7717
7718   // Start the animation
7719   animation.Play();
7720
7721   bool signalReceived(false);
7722   AnimationFinishCheck finishCheck(signalReceived);
7723   animation.FinishedSignal().Connect(&application, finishCheck);
7724
7725   application.SendNotification();
7726   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7727
7728   // We didn't expect the animation to finish yet
7729   application.SendNotification();
7730   finishCheck.CheckSignalNotReceived();
7731   DALI_TEST_EQUALS( actor.GetCurrentScale().z, fiftyPercentProgress, TEST_LOCATION );
7732   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7733   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7734   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), fiftyPercentProgress, TEST_LOCATION );
7735
7736   application.SendNotification();
7737   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7738
7739   // We did expect the animation to finish
7740   application.SendNotification();
7741   finishCheck.CheckSignalReceived();
7742   DALI_TEST_EQUALS( actor.GetCurrentScale().z, targetZ, TEST_LOCATION );
7743   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
7744   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
7745   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), targetZ, TEST_LOCATION );
7746   END_TEST;
7747 }
7748
7749 int UtcDaliAnimationAnimateToActorColorP(void)
7750 {
7751   TestApplication application;
7752
7753   Actor actor = Actor::New();
7754   Stage::GetCurrent().Add(actor);
7755   DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
7756
7757   // Build the animation
7758   float durationSeconds(1.0f);
7759   Animation animation = Animation::New(durationSeconds);
7760   Vector4 targetColor(Color::RED);
7761   animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor );
7762
7763   Vector4 tenPercentProgress(Vector4(1.0f, 0.9f, 0.9f, 1.0f));
7764   Vector4 twentyPercentProgress(Vector4(1.0f, 0.8f, 0.8f, 1.0f));
7765
7766   // Start the animation
7767   animation.Play();
7768
7769   bool signalReceived(false);
7770   AnimationFinishCheck finishCheck(signalReceived);
7771   animation.FinishedSignal().Connect(&application, finishCheck);
7772
7773   application.SendNotification();
7774   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
7775
7776   // We didn't expect the animation to finish yet
7777   application.SendNotification();
7778   finishCheck.CheckSignalNotReceived();
7779   DALI_TEST_EQUALS( actor.GetCurrentColor(), tenPercentProgress, TEST_LOCATION );
7780
7781   application.SendNotification();
7782   application.Render(static_cast<unsigned int>(durationSeconds*900.0f) + 1u/*just beyond the animation duration*/);
7783
7784   // We did expect the animation to finish
7785   application.SendNotification();
7786   finishCheck.CheckSignalReceived();
7787   DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
7788
7789   // Reset everything
7790   finishCheck.Reset();
7791   actor.SetColor(Color::WHITE);
7792   application.SendNotification();
7793   application.Render(0);
7794   DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
7795
7796   // Repeat with a different (ease-in) alpha function
7797   animation = Animation::New(durationSeconds);
7798   animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::EASE_IN);
7799   animation.FinishedSignal().Connect(&application, finishCheck);
7800   animation.Play();
7801
7802   application.SendNotification();
7803   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
7804
7805   // We didn't expect the animation to finish yet
7806   application.SendNotification();
7807   finishCheck.CheckSignalNotReceived();
7808
7809   // The color should have changed less, than with a linear alpha function
7810   Vector4 current(actor.GetCurrentColor());
7811   DALI_TEST_CHECK( current.x == 1.0f ); // doesn't change
7812   DALI_TEST_CHECK( current.y < 1.0f );
7813   DALI_TEST_CHECK( current.y > tenPercentProgress.y );
7814   DALI_TEST_CHECK( current.z  < 1.0f );
7815   DALI_TEST_CHECK( current.z  > tenPercentProgress.z );
7816   DALI_TEST_CHECK( current.w == 1.0f ); // doesn't change
7817
7818   application.SendNotification();
7819   application.Render(static_cast<unsigned int>(durationSeconds*900.0f) + 1u/*just beyond the animation duration*/);
7820
7821   // We did expect the animation to finish
7822   application.SendNotification();
7823   finishCheck.CheckSignalReceived();
7824   DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
7825
7826   // Reset everything
7827   finishCheck.Reset();
7828   actor.SetColor(Color::WHITE);
7829   application.SendNotification();
7830   application.Render(0);
7831   DALI_TEST_EQUALS( actor.GetCurrentColor(), Color::WHITE, TEST_LOCATION );
7832
7833   // Repeat with a shorter animator duration
7834   float animatorDuration = 0.5f;
7835   animation = Animation::New(durationSeconds);
7836   animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::LINEAR, TimePeriod(animatorDuration));
7837   animation.FinishedSignal().Connect(&application, finishCheck);
7838   animation.Play();
7839
7840   application.SendNotification();
7841   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% animation progress, 20% animator progress */);
7842
7843   // We didn't expect the animation to finish yet
7844   application.SendNotification();
7845   finishCheck.CheckSignalNotReceived();
7846   DALI_TEST_EQUALS( actor.GetCurrentColor(), twentyPercentProgress, TEST_LOCATION );
7847
7848   application.SendNotification();
7849   application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 50% animation progress, 100% animator progress */);
7850
7851   // We didn't expect the animation to finish yet
7852   application.SendNotification();
7853   finishCheck.CheckSignalNotReceived();
7854   DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
7855
7856   application.SendNotification();
7857   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7858
7859   // We did expect the animation to finish
7860   application.SendNotification();
7861   finishCheck.CheckSignalReceived();
7862   DALI_TEST_EQUALS( actor.GetCurrentColor(), targetColor, TEST_LOCATION );
7863   END_TEST;
7864 }
7865
7866 int UtcDaliAnimationAnimateToActorColorRedP(void)
7867 {
7868   TestApplication application;
7869
7870   Actor actor = Actor::New();
7871   Stage::GetCurrent().Add(actor);
7872   float startValue(1.0f);
7873   DALI_TEST_EQUALS( actor.GetCurrentColor().r, startValue, TEST_LOCATION );
7874   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
7875   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
7876   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
7877   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7878
7879   // Build the animation
7880   float durationSeconds(1.0f);
7881   Animation animation = Animation::New(durationSeconds);
7882   float targetRed(0.5f);
7883   animation.AnimateTo( Property(actor, Actor::Property::COLOR_RED), targetRed );
7884
7885   float fiftyPercentProgress(startValue + (targetRed - startValue)*0.5f);
7886
7887   // Start the animation
7888   animation.Play();
7889
7890   bool signalReceived(false);
7891   AnimationFinishCheck finishCheck(signalReceived);
7892   animation.FinishedSignal().Connect(&application, finishCheck);
7893
7894   application.SendNotification();
7895   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7896
7897   // We didn't expect the animation to finish yet
7898   application.SendNotification();
7899   finishCheck.CheckSignalNotReceived();
7900   DALI_TEST_EQUALS( actor.GetCurrentColor().r, fiftyPercentProgress, TEST_LOCATION );
7901   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   fiftyPercentProgress, TEST_LOCATION );
7902   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue,           TEST_LOCATION );
7903   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue,           TEST_LOCATION );
7904   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue,           TEST_LOCATION );
7905
7906   application.SendNotification();
7907   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7908
7909   // We did expect the animation to finish
7910   application.SendNotification();
7911   finishCheck.CheckSignalReceived();
7912   DALI_TEST_EQUALS( actor.GetCurrentColor().r, targetRed, TEST_LOCATION );
7913   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   targetRed,  TEST_LOCATION );
7914   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
7915   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
7916   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7917   END_TEST;
7918 }
7919
7920 int UtcDaliAnimationAnimateToActorColorGreenP(void)
7921 {
7922   TestApplication application;
7923
7924   Actor actor = Actor::New();
7925   Stage::GetCurrent().Add(actor);
7926   float startValue(1.0f);
7927   DALI_TEST_EQUALS( actor.GetCurrentColor().g, startValue, TEST_LOCATION );
7928   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
7929   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
7930   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
7931   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7932
7933   // Build the animation
7934   float durationSeconds(1.0f);
7935   Animation animation = Animation::New(durationSeconds);
7936   float targetGreen(0.5f);
7937   animation.AnimateTo( Property(actor, Actor::Property::COLOR_GREEN), targetGreen );
7938
7939   float fiftyPercentProgress(startValue + (targetGreen - startValue)*0.5f);
7940
7941   // Start the animation
7942   animation.Play();
7943
7944   bool signalReceived(false);
7945   AnimationFinishCheck finishCheck(signalReceived);
7946   animation.FinishedSignal().Connect(&application, finishCheck);
7947
7948   application.SendNotification();
7949   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
7950
7951   // We didn't expect the animation to finish yet
7952   application.SendNotification();
7953   finishCheck.CheckSignalNotReceived();
7954   DALI_TEST_EQUALS( actor.GetCurrentColor().g, fiftyPercentProgress, TEST_LOCATION );
7955   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue,           TEST_LOCATION );
7956   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), fiftyPercentProgress, TEST_LOCATION );
7957   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue,           TEST_LOCATION );
7958   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue,           TEST_LOCATION );
7959
7960   application.SendNotification();
7961   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
7962
7963   // We did expect the animation to finish
7964   application.SendNotification();
7965   finishCheck.CheckSignalReceived();
7966   DALI_TEST_EQUALS( actor.GetCurrentColor().g, targetGreen, TEST_LOCATION );
7967   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue,  TEST_LOCATION );
7968   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), targetGreen, TEST_LOCATION );
7969   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue,  TEST_LOCATION );
7970   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue,  TEST_LOCATION );
7971   END_TEST;
7972 }
7973
7974 int UtcDaliAnimationAnimateToActorColorBlueP(void)
7975 {
7976   TestApplication application;
7977
7978   Actor actor = Actor::New();
7979   Stage::GetCurrent().Add(actor);
7980   float startValue(1.0f);
7981   DALI_TEST_EQUALS( actor.GetCurrentColor().b, startValue, TEST_LOCATION );
7982   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
7983   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
7984   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
7985   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
7986
7987   // Build the animation
7988   float durationSeconds(1.0f);
7989   Animation animation = Animation::New(durationSeconds);
7990   float targetBlue(0.5f);
7991   animation.AnimateTo( Property(actor, Actor::Property::COLOR_BLUE), targetBlue );
7992
7993   float fiftyPercentProgress(startValue + (targetBlue - startValue)*0.5f);
7994
7995   // Start the animation
7996   animation.Play();
7997
7998   bool signalReceived(false);
7999   AnimationFinishCheck finishCheck(signalReceived);
8000   animation.FinishedSignal().Connect(&application, finishCheck);
8001
8002   application.SendNotification();
8003   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
8004
8005   // We didn't expect the animation to finish yet
8006   application.SendNotification();
8007   finishCheck.CheckSignalNotReceived();
8008   DALI_TEST_EQUALS( actor.GetCurrentColor().b, fiftyPercentProgress, TEST_LOCATION );
8009   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue,           TEST_LOCATION );
8010   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue,           TEST_LOCATION );
8011   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  fiftyPercentProgress, TEST_LOCATION );
8012   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue,           TEST_LOCATION );
8013
8014   application.SendNotification();
8015   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
8016
8017   // We did expect the animation to finish
8018   application.SendNotification();
8019   finishCheck.CheckSignalReceived();
8020   DALI_TEST_EQUALS( actor.GetCurrentColor().b, targetBlue, TEST_LOCATION );
8021   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8022   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8023   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  targetBlue, TEST_LOCATION );
8024   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8025   END_TEST;
8026 }
8027
8028 int UtcDaliAnimationAnimateToActorColorAlphaP(void)
8029 {
8030   TestApplication application;
8031
8032   Actor actor = Actor::New();
8033   Stage::GetCurrent().Add(actor);
8034   float startValue(1.0f);
8035   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8036   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8037   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8038   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8039   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8040
8041   // Build the animation
8042   float durationSeconds(1.0f);
8043   Animation animation = Animation::New(durationSeconds);
8044   float targetAlpha(0.5f);
8045   animation.AnimateTo( Property(actor, Actor::Property::COLOR_ALPHA), targetAlpha );
8046
8047   float fiftyPercentProgress(startValue + (targetAlpha - startValue)*0.5f);
8048
8049   // Start the animation
8050   animation.Play();
8051
8052   bool signalReceived(false);
8053   AnimationFinishCheck finishCheck(signalReceived);
8054   animation.FinishedSignal().Connect(&application, finishCheck);
8055
8056   application.SendNotification();
8057   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
8058
8059   // We didn't expect the animation to finish yet
8060   application.SendNotification();
8061   finishCheck.CheckSignalNotReceived();
8062   DALI_TEST_EQUALS( actor.GetCurrentColor().a, fiftyPercentProgress, TEST_LOCATION );
8063   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue,           TEST_LOCATION );
8064   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue,           TEST_LOCATION );
8065   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue,           TEST_LOCATION );
8066   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), fiftyPercentProgress, TEST_LOCATION );
8067
8068   application.SendNotification();
8069   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
8070
8071   // We did expect the animation to finish
8072   application.SendNotification();
8073   finishCheck.CheckSignalReceived();
8074   DALI_TEST_EQUALS( actor.GetCurrentColor().a, targetAlpha, TEST_LOCATION );
8075   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue,  TEST_LOCATION );
8076   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue,  TEST_LOCATION );
8077   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue,  TEST_LOCATION );
8078   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), targetAlpha, TEST_LOCATION );
8079   END_TEST;
8080 }
8081
8082 int UtcDaliAnimationKeyFrames01P(void)
8083 {
8084   TestApplication application;
8085
8086   KeyFrames keyFrames = KeyFrames::New();
8087   DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8088
8089   keyFrames.Add(0.0f, 0.1f);
8090
8091   DALI_TEST_EQUALS(keyFrames.GetType(), Property::FLOAT, TEST_LOCATION);
8092
8093   KeyFrames keyFrames2( keyFrames);
8094   DALI_TEST_CHECK( keyFrames2 );
8095   DALI_TEST_EQUALS(keyFrames2.GetType(), Property::FLOAT, TEST_LOCATION);
8096
8097   KeyFrames keyFrames3 = KeyFrames::New();
8098   keyFrames3.Add(0.6f, true);
8099   DALI_TEST_CHECK( keyFrames3 );
8100   DALI_TEST_EQUALS(keyFrames3.GetType(), Property::BOOLEAN, TEST_LOCATION);
8101
8102   keyFrames3 = keyFrames;
8103   DALI_TEST_CHECK( keyFrames3 );
8104   DALI_TEST_EQUALS(keyFrames3.GetType(), Property::FLOAT, TEST_LOCATION);
8105
8106   END_TEST;
8107 }
8108
8109 int UtcDaliAnimationKeyFrames02P(void)
8110 {
8111   TestApplication application;
8112
8113   KeyFrames keyFrames = KeyFrames::New();
8114   DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8115
8116   keyFrames.Add(0.0f, 0.1f);
8117   keyFrames.Add(0.2f, 0.5f);
8118   keyFrames.Add(0.4f, 0.0f);
8119   keyFrames.Add(0.6f, 1.0f);
8120   keyFrames.Add(0.8f, 0.7f);
8121   keyFrames.Add(1.0f, 0.9f);
8122
8123   DALI_TEST_EQUALS(keyFrames.GetType(), Property::FLOAT, TEST_LOCATION);
8124
8125   try
8126   {
8127     keyFrames.Add(1.9f, false);
8128   }
8129   catch (Dali::DaliException& e)
8130   {
8131     DALI_TEST_PRINT_ASSERT( e );
8132     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8133   }
8134   END_TEST;
8135 }
8136
8137 int UtcDaliAnimationKeyFrames03P(void)
8138 {
8139   TestApplication application;
8140
8141   KeyFrames keyFrames = KeyFrames::New();
8142   DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8143
8144   keyFrames.Add(0.0f, true);
8145   keyFrames.Add(0.2f, false);
8146   keyFrames.Add(0.4f, false);
8147   keyFrames.Add(0.6f, true);
8148   keyFrames.Add(0.8f, true);
8149   keyFrames.Add(1.0f, false);
8150
8151   DALI_TEST_EQUALS(keyFrames.GetType(), Property::BOOLEAN, TEST_LOCATION);
8152
8153   try
8154   {
8155     keyFrames.Add(0.7f, Vector3(1.0f, 1.0f, 1.0f));
8156   }
8157   catch (Dali::DaliException& e)
8158   {
8159     DALI_TEST_PRINT_ASSERT( e );
8160     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8161   }
8162   END_TEST;
8163 }
8164
8165 int UtcDaliAnimationKeyFrames04P(void)
8166 {
8167   TestApplication application;
8168
8169   KeyFrames keyFrames = KeyFrames::New();
8170   DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8171
8172   keyFrames.Add(0.0f, Vector2(0.0f, 0.0f));
8173   keyFrames.Add(0.2f, Vector2(1.0f, 1.0f));
8174   keyFrames.Add(0.4f, Vector2(2.0f, 2.0f));
8175   keyFrames.Add(0.6f, Vector2(3.0f, 5.0f));
8176   keyFrames.Add(0.8f, Vector2(4.0f, 3.0f));
8177   keyFrames.Add(1.0f, Vector2(6.0f, 2.0f));
8178
8179   DALI_TEST_EQUALS(keyFrames.GetType(), Property::VECTOR2, TEST_LOCATION);
8180
8181   try
8182   {
8183     keyFrames.Add(0.7f, Vector3(1.0f, 1.0f, 1.0f));
8184   }
8185   catch (Dali::DaliException& e)
8186   {
8187     DALI_TEST_PRINT_ASSERT( e );
8188     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8189   }
8190   END_TEST;
8191 }
8192
8193 int UtcDaliAnimationKeyFrames05P(void)
8194 {
8195   TestApplication application;
8196
8197   KeyFrames keyFrames = KeyFrames::New();
8198   DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8199
8200   keyFrames.Add(0.0f, Vector3(0.0f, 4.0f, 0.0f));
8201   keyFrames.Add(0.2f, Vector3(1.0f, 3.0f, 1.0f));
8202   keyFrames.Add(0.4f, Vector3(2.0f, 2.0f, 2.0f));
8203   keyFrames.Add(0.6f, Vector3(3.0f, 2.0f, 5.0f));
8204   keyFrames.Add(0.8f, Vector3(4.0f, 4.0f, 3.0f));
8205   keyFrames.Add(1.0f, Vector3(6.0f, 8.0f, 2.0f));
8206
8207   DALI_TEST_EQUALS(keyFrames.GetType(), Property::VECTOR3, TEST_LOCATION);
8208
8209   try
8210   {
8211     keyFrames.Add(0.7f, 1.0f);
8212   }
8213   catch (Dali::DaliException& e)
8214   {
8215     DALI_TEST_PRINT_ASSERT( e );
8216     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8217   }
8218   END_TEST;
8219 }
8220
8221 int UtcDaliAnimationKeyFrames06P(void)
8222 {
8223   TestApplication application;
8224
8225   KeyFrames keyFrames = KeyFrames::New();
8226   DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8227
8228   keyFrames.Add(0.0f, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
8229   keyFrames.Add(0.2f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
8230   keyFrames.Add(0.4f, Vector4(2.0f, 2.0f, 2.0f, 2.0f));
8231   keyFrames.Add(0.6f, Vector4(3.0f, 5.0f, 3.0f, 5.0f));
8232   keyFrames.Add(0.8f, Vector4(4.0f, 3.0f, 4.0f, 3.0f));
8233   keyFrames.Add(1.0f, Vector4(6.0f, 2.0f, 6.0f, 2.0f));
8234
8235   DALI_TEST_EQUALS(keyFrames.GetType(), Property::VECTOR4, TEST_LOCATION);
8236
8237   try
8238   {
8239     keyFrames.Add(0.7f, Quaternion(Radian(1.717f), Vector3::XAXIS));
8240   }
8241   catch (Dali::DaliException& e)
8242   {
8243     DALI_TEST_PRINT_ASSERT( e );
8244     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8245   }
8246   END_TEST;
8247 }
8248
8249 int UtcDaliAnimationKeyFrames07P(void)
8250 {
8251   TestApplication application;
8252
8253   KeyFrames keyFrames = KeyFrames::New();
8254   DALI_TEST_EQUALS(keyFrames.GetType(), Property::NONE, TEST_LOCATION);
8255
8256   keyFrames.Add(0.0f, Quaternion(Radian(1.717f), Vector3::XAXIS));
8257   keyFrames.Add(0.2f, Quaternion(Radian(2.0f), Vector3::XAXIS));
8258   keyFrames.Add(0.4f, Quaternion(Radian(3.0f), Vector3::ZAXIS));
8259   keyFrames.Add(0.6f, Quaternion(Radian(4.0f), Vector3(1.0f, 1.0f, 1.0f)));
8260   keyFrames.Add(0.8f, AngleAxis(Degree(90), Vector3::XAXIS));
8261   keyFrames.Add(1.0f, Quaternion(Radian(3.0f), Vector3::YAXIS));
8262
8263   DALI_TEST_EQUALS(keyFrames.GetType(), Property::ROTATION, TEST_LOCATION);
8264
8265   try
8266   {
8267     keyFrames.Add(0.7f, 1.1f);
8268   }
8269   catch (Dali::DaliException& e)
8270   {
8271     DALI_TEST_PRINT_ASSERT( e );
8272     DALI_TEST_ASSERT(e, "mType == value.GetType()", TEST_LOCATION);
8273   }
8274   END_TEST;
8275 }
8276
8277 int UtcDaliAnimationAnimateBetweenActorColorAlphaP(void)
8278 {
8279   TestApplication application;
8280
8281   float startValue(1.0f);
8282   Actor actor = Actor::New();
8283   actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
8284   Stage::GetCurrent().Add(actor);
8285
8286   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8287   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8288   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8289   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8290   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8291
8292   // Build the animation
8293   float durationSeconds(1.0f);
8294   Animation animation = Animation::New(durationSeconds);
8295
8296   KeyFrames keyFrames = KeyFrames::New();
8297   keyFrames.Add(0.0f, 0.1f);
8298   keyFrames.Add(0.2f, 0.5f);
8299   keyFrames.Add(0.4f, 0.0f);
8300   keyFrames.Add(0.6f, 1.0f);
8301   keyFrames.Add(0.8f, 0.7f);
8302   keyFrames.Add(1.0f, 0.9f);
8303
8304   animation.AnimateBetween( Property(actor, Actor::Property::COLOR_ALPHA), keyFrames );
8305
8306   // Start the animation
8307   animation.Play();
8308
8309   bool signalReceived(false);
8310   AnimationFinishCheck finishCheck(signalReceived);
8311   animation.FinishedSignal().Connect(&application, finishCheck);
8312   application.SendNotification();
8313   application.Render(0);
8314   application.SendNotification();
8315   finishCheck.CheckSignalNotReceived();
8316   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.1f, TEST_LOCATION );
8317
8318   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
8319   application.SendNotification();
8320   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8321   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8322   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8323   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.3f, 0.01f, TEST_LOCATION );
8324   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.3f, 0.01f, TEST_LOCATION );
8325
8326   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
8327   application.SendNotification();
8328   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8329   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8330   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8331   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.25f, 0.01f, TEST_LOCATION );
8332   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.25f, 0.01f, TEST_LOCATION );
8333
8334   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 40% progress */);
8335   application.SendNotification();
8336   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8337   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8338   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8339   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.0f, 0.01f, TEST_LOCATION );
8340   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.0f, 0.01f, TEST_LOCATION );
8341
8342   application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 80% progress */);
8343   application.SendNotification();
8344   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8345   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8346   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8347   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7f, 0.01f, TEST_LOCATION );
8348   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.7f, 0.01f, TEST_LOCATION );
8349
8350   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 90% progress */);
8351   application.SendNotification();
8352   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8353   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8354   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8355   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.8f, 0.01f, TEST_LOCATION );
8356   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.8f, 0.01f, TEST_LOCATION );
8357
8358   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)+1/* 100% progress */);
8359   application.SendNotification();
8360   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8361   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8362   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8363   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.9f, 0.01f, TEST_LOCATION );
8364   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.9f, 0.01f, TEST_LOCATION );
8365
8366   // We did expect the animation to finish
8367
8368   finishCheck.CheckSignalReceived();
8369   END_TEST;
8370 }
8371
8372 int UtcDaliAnimationAnimateBetweenActorColorAlphaCubicP(void)
8373 {
8374   TestApplication application;
8375
8376   float startValue(1.0f);
8377   Actor actor = Actor::New();
8378   actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
8379   Stage::GetCurrent().Add(actor);
8380
8381   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8382   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8383   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8384   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8385   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8386
8387   // Build the animation
8388   float durationSeconds(1.0f);
8389   Animation animation = Animation::New(durationSeconds);
8390
8391   KeyFrames keyFrames = KeyFrames::New();
8392   keyFrames.Add(0.0f, 0.1f);
8393   keyFrames.Add(0.2f, 0.5f);
8394   keyFrames.Add(0.4f, 0.0f);
8395   keyFrames.Add(0.6f, 1.0f);
8396   keyFrames.Add(0.8f, 0.7f);
8397   keyFrames.Add(1.0f, 0.9f);
8398
8399   animation.AnimateBetween( Property(actor, Actor::Property::COLOR_ALPHA), keyFrames, Animation::Cubic );
8400
8401   // Start the animation
8402   animation.Play();
8403
8404   bool signalReceived(false);
8405   AnimationFinishCheck finishCheck(signalReceived);
8406   animation.FinishedSignal().Connect(&application, finishCheck);
8407   application.SendNotification();
8408   application.Render(0);
8409   application.SendNotification();
8410   finishCheck.CheckSignalNotReceived();
8411   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.1f, TEST_LOCATION );
8412
8413   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
8414   application.SendNotification();
8415   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8416   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8417   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8418   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.36f, 0.01f, TEST_LOCATION );
8419   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.36f, 0.01f, TEST_LOCATION );
8420
8421   application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
8422   application.SendNotification();
8423   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8424   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8425   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8426   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.21f, 0.01f, TEST_LOCATION );
8427   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.21f, 0.01f, TEST_LOCATION );
8428
8429   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 40% progress */);
8430   application.SendNotification();
8431   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8432   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8433   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8434   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.0f, 0.01f, TEST_LOCATION );
8435   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.0f, 0.01f, TEST_LOCATION );
8436
8437   application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 80% progress */);
8438   application.SendNotification();
8439   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8440   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8441   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8442   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7f, 0.01f, TEST_LOCATION );
8443   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.7f, 0.01f, TEST_LOCATION );
8444
8445   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 90% progress */);
8446   application.SendNotification();
8447   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8448   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8449   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8450   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.76f, 0.01f, TEST_LOCATION );
8451   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.76f, 0.01f, TEST_LOCATION );
8452
8453   application.Render(static_cast<unsigned int>(durationSeconds*100.0f)+1/* 100% progress */);
8454   application.SendNotification();
8455   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8456   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8457   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8458   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.9f, 0.01f, TEST_LOCATION );
8459   DALI_TEST_EQUALS( actor.GetCurrentColor().a, 0.9f, 0.01f, TEST_LOCATION );
8460
8461   // We did expect the animation to finish
8462
8463   finishCheck.CheckSignalReceived();
8464   END_TEST;
8465 }
8466
8467 int UtcDaliAnimationAnimateBetweenActorColorP(void)
8468 {
8469   TestApplication application;
8470
8471   float startValue(1.0f);
8472   Actor actor = Actor::New();
8473   actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
8474   Stage::GetCurrent().Add(actor);
8475
8476   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8477   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8478   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8479   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8480   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8481
8482   // Build the animation
8483   float durationSeconds(1.0f);
8484   Animation animation = Animation::New(durationSeconds);
8485
8486   KeyFrames keyFrames = KeyFrames::New();
8487   keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
8488   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
8489   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
8490
8491   animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames );
8492
8493   // Start the animation
8494   animation.Play();
8495
8496   bool signalReceived(false);
8497   AnimationFinishCheck finishCheck(signalReceived);
8498   animation.FinishedSignal().Connect(&application, finishCheck);
8499   application.SendNotification();
8500   application.Render(0);
8501   application.SendNotification();
8502   finishCheck.CheckSignalNotReceived();
8503   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
8504   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
8505   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
8506   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
8507
8508   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
8509   application.SendNotification();
8510   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
8511   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
8512   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
8513   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
8514
8515   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
8516   application.SendNotification();
8517   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
8518   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
8519   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
8520   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
8521
8522   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
8523   application.SendNotification();
8524   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
8525   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
8526   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
8527   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
8528
8529   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
8530   application.SendNotification();
8531   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
8532   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
8533   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
8534   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
8535
8536   // We did expect the animation to finish
8537
8538   finishCheck.CheckSignalReceived();
8539   END_TEST;
8540 }
8541
8542 int UtcDaliAnimationAnimateBetweenActorColorCubicP(void)
8543 {
8544   TestApplication application;
8545
8546   float startValue(1.0f);
8547   Actor actor = Actor::New();
8548   actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
8549   Stage::GetCurrent().Add(actor);
8550
8551   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8552   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8553   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8554   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8555   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8556
8557   // Build the animation
8558   float durationSeconds(1.0f);
8559   Animation animation = Animation::New(durationSeconds);
8560
8561   KeyFrames keyFrames = KeyFrames::New();
8562   keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
8563   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
8564   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
8565
8566   animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, Animation::Cubic );
8567
8568   // Start the animation
8569   animation.Play();
8570
8571   bool signalReceived(false);
8572   AnimationFinishCheck finishCheck(signalReceived);
8573   animation.FinishedSignal().Connect(&application, finishCheck);
8574   application.SendNotification();
8575   application.Render(0);
8576   application.SendNotification();
8577   finishCheck.CheckSignalNotReceived();
8578   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
8579   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
8580   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
8581   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
8582
8583   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
8584   application.SendNotification();
8585   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.55f, 0.01f, TEST_LOCATION );
8586   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION );
8587   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.506f, 0.01f, TEST_LOCATION );
8588   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION );
8589
8590   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
8591   application.SendNotification();
8592   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
8593   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
8594   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
8595   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
8596
8597   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
8598   application.SendNotification();
8599   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.99375f, 0.01f, TEST_LOCATION );
8600   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION );
8601   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85625f, 0.01f, TEST_LOCATION );
8602   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION );
8603
8604   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
8605   application.SendNotification();
8606   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
8607   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
8608   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
8609   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
8610
8611   // We did expect the animation to finish
8612
8613   finishCheck.CheckSignalReceived();
8614   END_TEST;
8615 }
8616
8617 int UtcDaliAnimationAnimateBetweenActorVisibleP(void)
8618 {
8619   TestApplication application;
8620
8621   Actor actor = Actor::New();
8622   AngleAxis aa(Degree(90), Vector3::XAXIS);
8623   actor.SetOrientation(aa.angle, aa.axis);
8624   Stage::GetCurrent().Add(actor);
8625
8626   application.SendNotification();
8627   application.Render(0);
8628
8629   DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION );
8630
8631   // Build the animation
8632   float durationSeconds(1.0f);
8633   Animation animation = Animation::New(durationSeconds);
8634
8635   KeyFrames keyFrames = KeyFrames::New();
8636   keyFrames.Add(0.0f, false);
8637   keyFrames.Add(0.2f, true);
8638   keyFrames.Add(0.4f, true);
8639   keyFrames.Add(0.8f, false);
8640   keyFrames.Add(1.0f, true);
8641
8642   animation.AnimateBetween( Property(actor, Actor::Property::VISIBLE), keyFrames );
8643
8644   // Start the animation
8645   animation.Play();
8646
8647   bool signalReceived(false);
8648   AnimationFinishCheck finishCheck(signalReceived);
8649   animation.FinishedSignal().Connect(&application, finishCheck);
8650   application.SendNotification();
8651   application.SendNotification();
8652   application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
8653   application.SendNotification();
8654   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
8655   application.SendNotification();
8656
8657   DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION);
8658   finishCheck.CheckSignalReceived();
8659   END_TEST;
8660 }
8661
8662 int UtcDaliAnimationAnimateBetweenActorVisibleCubicP(void)
8663 {
8664   TestApplication application;
8665
8666   Actor actor = Actor::New();
8667   AngleAxis aa(Degree(90), Vector3::XAXIS);
8668   actor.SetOrientation(aa.angle, aa.axis);
8669   Stage::GetCurrent().Add(actor);
8670
8671   application.SendNotification();
8672   application.Render(0);
8673
8674   DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION );
8675
8676   // Build the animation
8677   float durationSeconds(1.0f);
8678   Animation animation = Animation::New(durationSeconds);
8679
8680   KeyFrames keyFrames = KeyFrames::New();
8681   keyFrames.Add(0.0f, false);
8682   keyFrames.Add(0.2f, true);
8683   keyFrames.Add(0.4f, true);
8684   keyFrames.Add(0.8f, false);
8685   keyFrames.Add(1.0f, true);
8686
8687   //Cubic interpolation for boolean values should be ignored
8688   animation.AnimateBetween( Property(actor, Actor::Property::VISIBLE), keyFrames, Animation::Cubic );
8689
8690   // Start the animation
8691   animation.Play();
8692
8693   bool signalReceived(false);
8694   AnimationFinishCheck finishCheck(signalReceived);
8695   animation.FinishedSignal().Connect(&application, finishCheck);
8696   application.SendNotification();
8697   application.SendNotification();
8698   application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
8699   application.SendNotification();
8700   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
8701   application.SendNotification();
8702
8703   DALI_TEST_EQUALS( actor.IsVisible(), true, TEST_LOCATION);
8704   finishCheck.CheckSignalReceived();
8705   END_TEST;
8706 }
8707
8708 int UtcDaliAnimationAnimateBetweenActorOrientation01P(void)
8709 {
8710   TestApplication application;
8711
8712   Actor actor = Actor::New();
8713   AngleAxis aa(Degree(90), Vector3::XAXIS);
8714   actor.SetOrientation(aa.angle, aa.axis);
8715   Stage::GetCurrent().Add(actor);
8716
8717   application.SendNotification();
8718   application.Render(0);
8719   Quaternion start(Radian(aa.angle), aa.axis);
8720   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), start, 0.001f, TEST_LOCATION );
8721
8722   // Build the animation
8723   float durationSeconds(1.0f);
8724   Animation animation = Animation::New(durationSeconds);
8725
8726   KeyFrames keyFrames = KeyFrames::New();
8727   keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::ZAXIS));
8728
8729   animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames );
8730
8731   // Start the animation
8732   animation.Play();
8733
8734   bool signalReceived(false);
8735   AnimationFinishCheck finishCheck(signalReceived);
8736   animation.FinishedSignal().Connect(&application, finishCheck);
8737   application.SendNotification();
8738   application.SendNotification();
8739   application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
8740   application.SendNotification();
8741   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
8742   application.SendNotification();
8743
8744   Quaternion check( Radian(Degree(60)), Vector3::ZAXIS );
8745
8746   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8747   finishCheck.CheckSignalReceived();
8748   END_TEST;
8749 }
8750
8751 int UtcDaliAnimationAnimateBetweenActorOrientation02P(void)
8752 {
8753   TestApplication application;
8754
8755   Actor actor = Actor::New();
8756   AngleAxis aa(Degree(90), Vector3::XAXIS);
8757   actor.SetOrientation(aa.angle, aa.axis);
8758   application.SendNotification();
8759   application.Render(0);
8760   Stage::GetCurrent().Add(actor);
8761
8762   Quaternion start(Radian(aa.angle), aa.axis);
8763   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), start, 0.001f, TEST_LOCATION );
8764
8765   // Build the animation
8766   float durationSeconds(1.0f);
8767   Animation animation = Animation::New(durationSeconds);
8768
8769   KeyFrames keyFrames = KeyFrames::New();
8770   keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::XAXIS));
8771   keyFrames.Add(0.5f, AngleAxis(Degree(120), Vector3::XAXIS));
8772   keyFrames.Add(1.0f, AngleAxis(Degree(120), Vector3::YAXIS));
8773
8774   animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames );
8775
8776   // Start the animation
8777   animation.Play();
8778
8779   bool signalReceived(false);
8780   AnimationFinishCheck finishCheck(signalReceived);
8781   animation.FinishedSignal().Connect(&application, finishCheck);
8782   application.SendNotification();
8783   application.Render(0);
8784   application.SendNotification();
8785   finishCheck.CheckSignalNotReceived();
8786
8787   Quaternion check(Radian(Degree(60)), Vector3::XAXIS);
8788   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8789
8790   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
8791   application.SendNotification();
8792   check = Quaternion( Radian(Degree(90)), Vector3::XAXIS );
8793   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8794
8795   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
8796   application.SendNotification();
8797   check = Quaternion( Radian(Degree(120)), Vector3::XAXIS );
8798   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8799
8800   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
8801   application.SendNotification();
8802   check = Quaternion( Radian(Degree(101.5)), Vector3(0.5f, 0.5f, 0.0f) );
8803   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8804
8805   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
8806   application.SendNotification();
8807   check = Quaternion( Radian(Degree(120)), Vector3::YAXIS );
8808   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8809
8810   // We did expect the animation to finish
8811
8812   finishCheck.CheckSignalReceived();
8813   END_TEST;
8814 }
8815
8816 int UtcDaliAnimationAnimateBetweenActorOrientation01CubicP(void)
8817 {
8818   TestApplication application;
8819
8820   Actor actor = Actor::New();
8821   AngleAxis aa(Degree(90), Vector3::XAXIS);
8822   actor.SetOrientation(aa.angle, aa.axis);
8823   Stage::GetCurrent().Add(actor);
8824
8825   application.SendNotification();
8826   application.Render(0);
8827   Quaternion start(Radian(aa.angle), aa.axis);
8828   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), start, 0.001f, TEST_LOCATION );
8829
8830   // Build the animation
8831   float durationSeconds(1.0f);
8832   Animation animation = Animation::New(durationSeconds);
8833
8834   KeyFrames keyFrames = KeyFrames::New();
8835   keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::ZAXIS));
8836
8837   //Cubic interpolation should be ignored for quaternions
8838   animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames, Animation::Cubic );
8839
8840   // Start the animation
8841   animation.Play();
8842
8843   bool signalReceived(false);
8844   AnimationFinishCheck finishCheck(signalReceived);
8845   animation.FinishedSignal().Connect(&application, finishCheck);
8846   application.SendNotification();
8847   application.SendNotification();
8848   application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
8849   application.SendNotification();
8850   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
8851   application.SendNotification();
8852
8853   Quaternion check( Radian(Degree(60)), Vector3::ZAXIS );
8854
8855   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8856   finishCheck.CheckSignalReceived();
8857   END_TEST;
8858 }
8859
8860 int UtcDaliAnimationAnimateBetweenActorOrientation02CubicP(void)
8861 {
8862   TestApplication application;
8863
8864   Actor actor = Actor::New();
8865   AngleAxis aa(Degree(90), Vector3::XAXIS);
8866   actor.SetOrientation(aa.angle, aa.axis);
8867   application.SendNotification();
8868   application.Render(0);
8869   Stage::GetCurrent().Add(actor);
8870
8871   Quaternion start(Radian(aa.angle), aa.axis);
8872   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), start, 0.001f, TEST_LOCATION );
8873
8874   // Build the animation
8875   float durationSeconds(1.0f);
8876   Animation animation = Animation::New(durationSeconds);
8877
8878   KeyFrames keyFrames = KeyFrames::New();
8879   keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::XAXIS));
8880   keyFrames.Add(0.5f, AngleAxis(Degree(120), Vector3::XAXIS));
8881   keyFrames.Add(1.0f, AngleAxis(Degree(120), Vector3::YAXIS));
8882
8883   //Cubic interpolation should be ignored for quaternions
8884   animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames, Animation::Cubic );
8885
8886   // Start the animation
8887   animation.Play();
8888
8889   bool signalReceived(false);
8890   AnimationFinishCheck finishCheck(signalReceived);
8891   animation.FinishedSignal().Connect(&application, finishCheck);
8892   application.SendNotification();
8893   application.Render(0);
8894   application.SendNotification();
8895   finishCheck.CheckSignalNotReceived();
8896
8897   Quaternion check(Radian(Degree(60)), Vector3::XAXIS);
8898   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8899
8900   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
8901   application.SendNotification();
8902   check = Quaternion( Radian(Degree(90)), Vector3::XAXIS );
8903   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8904
8905   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
8906   application.SendNotification();
8907   check = Quaternion( Radian(Degree(120)), Vector3::XAXIS );
8908   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8909
8910   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
8911   application.SendNotification();
8912   check = Quaternion( Radian(Degree(101.5)), Vector3(0.5f, 0.5f, 0.0f ) );
8913   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8914
8915   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
8916   application.SendNotification();
8917   check = Quaternion( Radian(Degree(120)), Vector3::YAXIS );
8918   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), check, 0.001f, TEST_LOCATION );
8919
8920   // We did expect the animation to finish
8921
8922   finishCheck.CheckSignalReceived();
8923   END_TEST;
8924 }
8925
8926 int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionP(void)
8927 {
8928   TestApplication application;
8929
8930   float startValue(1.0f);
8931   Actor actor = Actor::New();
8932   actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
8933   Stage::GetCurrent().Add(actor);
8934
8935   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
8936   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
8937   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
8938   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
8939   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
8940
8941   // Build the animation
8942   float durationSeconds(1.0f);
8943   Animation animation = Animation::New(durationSeconds);
8944
8945   KeyFrames keyFrames = KeyFrames::New();
8946   keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
8947   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
8948   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
8949
8950   animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR );
8951
8952   // Start the animation
8953   animation.Play();
8954
8955   bool signalReceived(false);
8956   AnimationFinishCheck finishCheck(signalReceived);
8957   animation.FinishedSignal().Connect(&application, finishCheck);
8958   application.SendNotification();
8959   application.Render(0);
8960   application.SendNotification();
8961   finishCheck.CheckSignalNotReceived();
8962   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
8963   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
8964   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
8965   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
8966
8967   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
8968   application.SendNotification();
8969   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
8970   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
8971   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
8972   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
8973
8974   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
8975   application.SendNotification();
8976   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
8977   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
8978   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
8979   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
8980
8981   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
8982   application.SendNotification();
8983   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
8984   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
8985   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
8986   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
8987
8988   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
8989   application.SendNotification();
8990   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
8991   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
8992   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
8993   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
8994
8995   // We did expect the animation to finish
8996
8997   finishCheck.CheckSignalReceived();
8998   END_TEST;
8999 }
9000
9001 int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionCubicP(void)
9002 {
9003   TestApplication application;
9004
9005   float startValue(1.0f);
9006   Actor actor = Actor::New();
9007   actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
9008   Stage::GetCurrent().Add(actor);
9009
9010   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
9011   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
9012   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
9013   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
9014   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
9015
9016   // Build the animation
9017   float durationSeconds(1.0f);
9018   Animation animation = Animation::New(durationSeconds);
9019
9020   KeyFrames keyFrames = KeyFrames::New();
9021   keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
9022   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
9023   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
9024
9025   animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, Animation::Cubic );
9026
9027   // Start the animation
9028   animation.Play();
9029
9030   bool signalReceived(false);
9031   AnimationFinishCheck finishCheck(signalReceived);
9032   animation.FinishedSignal().Connect(&application, finishCheck);
9033   application.SendNotification();
9034   application.Render(0);
9035   application.SendNotification();
9036   finishCheck.CheckSignalNotReceived();
9037   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
9038   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
9039   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
9040   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
9041
9042   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
9043   application.SendNotification();
9044   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.55f, 0.01f, TEST_LOCATION );
9045   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION );
9046   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.506f, 0.01f, TEST_LOCATION );
9047   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION );
9048
9049   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
9050   application.SendNotification();
9051   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
9052   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
9053   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
9054   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
9055
9056   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
9057   application.SendNotification();
9058   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.99375f, 0.01f, TEST_LOCATION );
9059   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION );
9060   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85625f, 0.01f, TEST_LOCATION );
9061   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION );
9062
9063   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
9064   application.SendNotification();
9065   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
9066   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
9067   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
9068   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
9069
9070   // We did expect the animation to finish
9071
9072   finishCheck.CheckSignalReceived();
9073   END_TEST;
9074 }
9075
9076 int UtcDaliAnimationAnimateBetweenActorColorTimePeriodP(void)
9077 {
9078   TestApplication application;
9079
9080   float startValue(1.0f);
9081   Actor actor = Actor::New();
9082   actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
9083   Stage::GetCurrent().Add(actor);
9084
9085   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
9086   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
9087   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
9088   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
9089   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
9090
9091   // Build the animation
9092   float durationSeconds(1.0f);
9093   float delay = 0.5f;
9094   Animation animation = Animation::New(durationSeconds);
9095
9096   KeyFrames keyFrames = KeyFrames::New();
9097   keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
9098   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
9099   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
9100
9101   animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, TimePeriod( delay, durationSeconds - delay ) );
9102
9103   // Start the animation
9104   animation.Play();
9105
9106   bool signalReceived(false);
9107   AnimationFinishCheck finishCheck(signalReceived);
9108   animation.FinishedSignal().Connect(&application, finishCheck);
9109   application.SendNotification();
9110
9111   application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
9112   application.SendNotification();
9113   finishCheck.CheckSignalNotReceived();
9114   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
9115   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
9116   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
9117   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
9118
9119   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
9120   application.SendNotification();
9121   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
9122   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
9123   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
9124   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
9125
9126   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
9127   application.SendNotification();
9128   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
9129   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
9130   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
9131   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
9132
9133   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
9134   application.SendNotification();
9135   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
9136   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
9137   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
9138   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
9139
9140   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
9141   application.SendNotification();
9142   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
9143   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
9144   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
9145   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
9146
9147   // We did expect the animation to finish
9148
9149   finishCheck.CheckSignalReceived();
9150   END_TEST;
9151 }
9152
9153 int UtcDaliAnimationAnimateBetweenActorColorTimePeriodCubicP(void)
9154 {
9155   TestApplication application;
9156
9157   float startValue(1.0f);
9158   Actor actor = Actor::New();
9159   actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
9160   Stage::GetCurrent().Add(actor);
9161
9162   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
9163   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
9164   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
9165   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
9166   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
9167
9168   // Build the animation
9169   float durationSeconds(1.0f);
9170   float delay = 0.5f;
9171   Animation animation = Animation::New(durationSeconds);
9172
9173   KeyFrames keyFrames = KeyFrames::New();
9174   keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
9175   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
9176   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
9177
9178   animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, TimePeriod( delay, durationSeconds - delay ), Animation::Cubic );
9179
9180   // Start the animation
9181   animation.Play();
9182
9183   bool signalReceived(false);
9184   AnimationFinishCheck finishCheck(signalReceived);
9185   animation.FinishedSignal().Connect(&application, finishCheck);
9186   application.SendNotification();
9187
9188   application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
9189   application.SendNotification();
9190   finishCheck.CheckSignalNotReceived();
9191   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
9192   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
9193   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
9194   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
9195
9196   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
9197   application.SendNotification();
9198   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.55f, 0.01f, TEST_LOCATION );
9199   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION );
9200   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.506f, 0.01f, TEST_LOCATION );
9201   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION );
9202
9203   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
9204   application.SendNotification();
9205   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
9206   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
9207   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
9208   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
9209
9210   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
9211   application.SendNotification();
9212   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.99375f, 0.01f, TEST_LOCATION );
9213   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION );
9214   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85625f, 0.01f, TEST_LOCATION );
9215   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION );
9216
9217   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
9218   application.SendNotification();
9219   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
9220   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
9221   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
9222   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
9223
9224   // We did expect the animation to finish
9225
9226   finishCheck.CheckSignalReceived();
9227   END_TEST;
9228 }
9229
9230 int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionTimePeriodP(void)
9231 {
9232   TestApplication application;
9233
9234   float startValue(1.0f);
9235   float delay = 0.5f;
9236   Actor actor = Actor::New();
9237   actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
9238   Stage::GetCurrent().Add(actor);
9239
9240   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
9241   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
9242   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
9243   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
9244   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
9245
9246   // Build the animation
9247   float durationSeconds(1.0f);
9248   Animation animation = Animation::New(durationSeconds);
9249
9250   KeyFrames keyFrames = KeyFrames::New();
9251   keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
9252   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
9253   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
9254
9255   animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
9256
9257   // Start the animation
9258   animation.Play();
9259
9260   bool signalReceived(false);
9261   AnimationFinishCheck finishCheck(signalReceived);
9262   animation.FinishedSignal().Connect(&application, finishCheck);
9263   application.SendNotification();
9264
9265   application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
9266   application.SendNotification();
9267   finishCheck.CheckSignalNotReceived();
9268   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
9269   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
9270   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
9271   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
9272
9273   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
9274   application.SendNotification();
9275   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.5f, 0.01f, TEST_LOCATION );
9276   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION );
9277   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.5f, 0.01f, TEST_LOCATION );
9278   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION );
9279
9280   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
9281   application.SendNotification();
9282   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
9283   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
9284   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
9285   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
9286
9287   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
9288   application.SendNotification();
9289   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.95f, 0.01f, TEST_LOCATION );
9290   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION );
9291   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85f, 0.01f, TEST_LOCATION );
9292   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION );
9293
9294   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
9295   application.SendNotification();
9296   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
9297   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
9298   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
9299   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
9300
9301   // We did expect the animation to finish
9302
9303   finishCheck.CheckSignalReceived();
9304   END_TEST;
9305 }
9306
9307 int UtcDaliAnimationAnimateBetweenActorColorCubicWithDelayP(void)
9308 {
9309   TestApplication application;
9310
9311   float startValue(1.0f);
9312   Actor actor = Actor::New();
9313   actor.SetColor(Vector4(startValue, startValue, startValue, startValue));
9314   Stage::GetCurrent().Add(actor);
9315
9316   DALI_TEST_EQUALS( actor.GetCurrentColor().a, startValue, TEST_LOCATION );
9317   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   startValue, TEST_LOCATION );
9318   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
9319   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  startValue, TEST_LOCATION );
9320   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
9321
9322   // Build the animation
9323   float durationSeconds(1.0f);
9324   float delay = 0.5f;
9325   Animation animation = Animation::New(durationSeconds);
9326
9327   KeyFrames keyFrames = KeyFrames::New();
9328   keyFrames.Add(0.0f, Vector4(0.1f, 0.2f, 0.3f, 0.4f));
9329   keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
9330   keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
9331
9332   animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ), Animation::Cubic );
9333
9334   // Start the animation
9335   animation.Play();
9336
9337   bool signalReceived(false);
9338   AnimationFinishCheck finishCheck(signalReceived);
9339   animation.FinishedSignal().Connect(&application, finishCheck);
9340   application.SendNotification();
9341
9342   application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
9343   application.SendNotification();
9344   finishCheck.CheckSignalNotReceived();
9345   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.1f, 0.01f, TEST_LOCATION );
9346   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION );
9347   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.3f, 0.01f, TEST_LOCATION );
9348   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION );
9349
9350   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
9351   application.SendNotification();
9352   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.55f, 0.01f, TEST_LOCATION );
9353   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION );
9354   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.506f, 0.01f, TEST_LOCATION );
9355   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION );
9356
9357   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
9358   application.SendNotification();
9359   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.9f, 0.01f, TEST_LOCATION );
9360   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
9361   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.7f, 0.01f, TEST_LOCATION );
9362   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION );
9363
9364   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
9365   application.SendNotification();
9366   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   0.99375f, 0.01f, TEST_LOCATION );
9367   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION );
9368   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  0.85625f, 0.01f, TEST_LOCATION );
9369   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION );
9370
9371   application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
9372   application.SendNotification();
9373   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED),   1.0f, 0.01f, TEST_LOCATION );
9374   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION );
9375   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE),  1.0f, 0.01f, TEST_LOCATION );
9376   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION );
9377
9378   // We did expect the animation to finish
9379
9380   finishCheck.CheckSignalReceived();
9381   END_TEST;
9382 }
9383
9384 int UtcDaliAnimationAnimateP(void)
9385 {
9386   TestApplication application;
9387
9388   Actor actor = Actor::New();
9389   Stage::GetCurrent().Add(actor);
9390
9391   //Build the path
9392   Vector3 position0( 30.0,  80.0,  0.0);
9393   Vector3 position1( 70.0,  120.0, 0.0);
9394   Vector3 position2( 100.0, 100.0, 0.0);
9395
9396   Dali::Path path = Dali::Path::New();
9397   path.AddPoint(position0);
9398   path.AddPoint(position1);
9399   path.AddPoint(position2);
9400
9401   //Control points for first segment
9402   path.AddControlPoint( Vector3( 39.0,  90.0, 0.0) );
9403   path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
9404
9405   //Control points for second segment
9406   path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
9407   path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
9408
9409   // Build the animation
9410   float durationSeconds( 1.0f );
9411   Animation animation = Animation::New(durationSeconds);
9412   animation.Animate(actor, path, Vector3::XAXIS);
9413
9414   // Start the animation
9415   animation.Play();
9416
9417   bool signalReceived(false);
9418   AnimationFinishCheck finishCheck(signalReceived);
9419   animation.FinishedSignal().Connect(&application, finishCheck);
9420   application.SendNotification();
9421   application.Render(0);
9422   application.SendNotification();
9423   finishCheck.CheckSignalNotReceived();
9424   Vector3 position, tangent;
9425   Quaternion rotation;
9426   path.Sample( 0.0f, position, tangent );
9427   rotation = Quaternion( Vector3::XAXIS, tangent );
9428   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9429   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9430
9431   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
9432   application.SendNotification();
9433   path.Sample( 0.25f, position, tangent );
9434   rotation = Quaternion( Vector3::XAXIS, tangent );
9435   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9436   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9437
9438   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
9439   application.SendNotification();
9440   path.Sample( 0.5f, position, tangent );
9441   rotation = Quaternion( Vector3::XAXIS, tangent );
9442   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9443   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9444
9445   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
9446   application.SendNotification();
9447   path.Sample( 0.75f, position, tangent );
9448   rotation = Quaternion( Vector3::XAXIS, tangent );
9449   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9450   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9451
9452   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
9453   application.SendNotification();
9454   path.Sample( 1.0f, position, tangent );
9455   rotation = Quaternion( Vector3::XAXIS, tangent );
9456   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9457   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9458
9459   finishCheck.CheckSignalReceived();
9460   END_TEST;
9461 }
9462
9463 int UtcDaliAnimationAnimateAlphaFunctionP(void)
9464 {
9465   TestApplication application;
9466
9467   Actor actor = Actor::New();
9468   Stage::GetCurrent().Add(actor);
9469
9470   //Build the path
9471   Vector3 position0( 30.0,  80.0,  0.0);
9472   Vector3 position1( 70.0,  120.0, 0.0);
9473   Vector3 position2( 100.0, 100.0, 0.0);
9474
9475   Dali::Path path = Dali::Path::New();
9476   path.AddPoint(position0);
9477   path.AddPoint(position1);
9478   path.AddPoint(position2);
9479
9480   //Control points for first segment
9481   path.AddControlPoint( Vector3( 39.0,  90.0, 0.0) );
9482   path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
9483
9484   //Control points for second segment
9485   path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
9486   path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
9487
9488   // Build the animation
9489   float durationSeconds( 1.0f );
9490   Animation animation = Animation::New(durationSeconds);
9491   animation.Animate(actor, path, Vector3::XAXIS, AlphaFunction::LINEAR);
9492
9493   // Start the animation
9494   animation.Play();
9495
9496   bool signalReceived(false);
9497   AnimationFinishCheck finishCheck(signalReceived);
9498   animation.FinishedSignal().Connect(&application, finishCheck);
9499   application.SendNotification();
9500   application.Render(0);
9501   application.SendNotification();
9502   finishCheck.CheckSignalNotReceived();
9503   Vector3 position, tangent;
9504   Quaternion rotation;
9505   path.Sample( 0.0f, position, tangent );
9506   rotation = Quaternion( Vector3::XAXIS, tangent );
9507   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9508   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9509
9510   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
9511   application.SendNotification();
9512   path.Sample( 0.25f, position, tangent );
9513   rotation = Quaternion( Vector3::XAXIS, tangent );
9514   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9515   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9516
9517   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
9518   application.SendNotification();
9519   path.Sample( 0.5f, position, tangent );
9520   rotation = Quaternion( Vector3::XAXIS, tangent );
9521   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9522   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9523
9524   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
9525   application.SendNotification();
9526   path.Sample( 0.75f, position, tangent );
9527   rotation = Quaternion( Vector3::XAXIS, tangent );
9528   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9529   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9530
9531   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
9532   application.SendNotification();
9533   path.Sample( 1.0f, position, tangent );
9534   rotation = Quaternion( Vector3::XAXIS, tangent );
9535   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9536   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9537
9538   finishCheck.CheckSignalReceived();
9539   END_TEST;
9540 }
9541
9542 int UtcDaliAnimationAnimateTimePeriodP(void)
9543 {
9544   TestApplication application;
9545
9546   Actor actor = Actor::New();
9547   Stage::GetCurrent().Add(actor);
9548
9549   //Build the path
9550   Vector3 position0( 30.0,  80.0,  0.0);
9551   Vector3 position1( 70.0,  120.0, 0.0);
9552   Vector3 position2( 100.0, 100.0, 0.0);
9553
9554   Dali::Path path = Dali::Path::New();
9555   path.AddPoint(position0);
9556   path.AddPoint(position1);
9557   path.AddPoint(position2);
9558
9559   //Control points for first segment
9560   path.AddControlPoint( Vector3( 39.0,  90.0, 0.0) );
9561   path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
9562
9563   //Control points for second segment
9564   path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
9565   path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
9566
9567   // Build the animation
9568   float durationSeconds( 1.0f );
9569   Animation animation = Animation::New(durationSeconds);
9570   animation.Animate(actor, path, Vector3::XAXIS, TimePeriod(0.0f, 1.0f));
9571
9572   // Start the animation
9573   animation.Play();
9574
9575   bool signalReceived(false);
9576   AnimationFinishCheck finishCheck(signalReceived);
9577   animation.FinishedSignal().Connect(&application, finishCheck);
9578   application.SendNotification();
9579   application.Render(0);
9580   application.SendNotification();
9581   finishCheck.CheckSignalNotReceived();
9582   Vector3 position, tangent;
9583   Quaternion rotation;
9584   path.Sample( 0.0f, position, tangent );
9585   rotation = Quaternion( Vector3::XAXIS, tangent );
9586   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9587   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9588
9589   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
9590   application.SendNotification();
9591   path.Sample( 0.25f, position, tangent );
9592   rotation = Quaternion( Vector3::XAXIS, tangent );
9593   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9594   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9595
9596   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
9597   application.SendNotification();
9598   path.Sample( 0.5f, position, tangent );
9599   rotation = Quaternion( Vector3::XAXIS, tangent );
9600   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9601   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9602
9603   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
9604   application.SendNotification();
9605   path.Sample( 0.75f, position, tangent );
9606   rotation = Quaternion( Vector3::XAXIS, tangent );
9607   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9608   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9609
9610   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
9611   application.SendNotification();
9612   path.Sample( 1.0f, position, tangent );
9613   rotation = Quaternion( Vector3::XAXIS, tangent );
9614   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9615   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9616
9617   finishCheck.CheckSignalReceived();
9618   END_TEST;
9619 }
9620
9621 int UtcDaliAnimationAnimateAlphaFunctionTimePeriodP(void)
9622 {
9623   TestApplication application;
9624
9625   Actor actor = Actor::New();
9626   Stage::GetCurrent().Add(actor);
9627
9628   //Build the path
9629   Vector3 position0( 30.0,  80.0,  0.0);
9630   Vector3 position1( 70.0,  120.0, 0.0);
9631   Vector3 position2( 100.0, 100.0, 0.0);
9632
9633   Dali::Path path = Dali::Path::New();
9634   path.AddPoint(position0);
9635   path.AddPoint(position1);
9636   path.AddPoint(position2);
9637
9638   //Control points for first segment
9639   path.AddControlPoint( Vector3( 39.0,  90.0, 0.0) );
9640   path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
9641
9642   //Control points for second segment
9643   path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
9644   path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
9645
9646   // Build the animation
9647   float durationSeconds( 1.0f );
9648   Animation animation = Animation::New(durationSeconds);
9649   animation.Animate(actor, path, Vector3::XAXIS, AlphaFunction::LINEAR, TimePeriod(0.0f, 1.0f));
9650
9651   // Start the animation
9652   animation.Play();
9653
9654   bool signalReceived(false);
9655   AnimationFinishCheck finishCheck(signalReceived);
9656   animation.FinishedSignal().Connect(&application, finishCheck);
9657   application.SendNotification();
9658   application.Render(0);
9659   application.SendNotification();
9660   finishCheck.CheckSignalNotReceived();
9661   Vector3 position, tangent;
9662   Quaternion rotation;
9663   path.Sample( 0.0f, position, tangent );
9664   rotation = Quaternion( Vector3::XAXIS, tangent );
9665   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9666   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9667
9668   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
9669   application.SendNotification();
9670   path.Sample( 0.25f, position, tangent );
9671   rotation = Quaternion( Vector3::XAXIS, tangent );
9672   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9673   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9674
9675   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
9676   application.SendNotification();
9677   path.Sample( 0.5f, position, tangent );
9678   rotation = Quaternion( Vector3::XAXIS, tangent );
9679   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9680   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9681
9682   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
9683   application.SendNotification();
9684   path.Sample( 0.75f, position, tangent );
9685   rotation = Quaternion( Vector3::XAXIS, tangent );
9686   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9687   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9688
9689   application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
9690   application.SendNotification();
9691   path.Sample( 1.0f, position, tangent );
9692   rotation = Quaternion( Vector3::XAXIS, tangent );
9693   DALI_TEST_EQUALS( actor.GetCurrentPosition(), position, TEST_LOCATION );
9694   DALI_TEST_EQUALS( actor.GetCurrentOrientation(), rotation, TEST_LOCATION );
9695
9696   finishCheck.CheckSignalReceived();
9697   END_TEST;
9698 }
9699
9700 int UtcDaliAnimationShowP(void)
9701 {
9702   TestApplication application;
9703
9704   Actor actor = Actor::New();
9705   actor.SetVisible(false);
9706   application.SendNotification();
9707   application.Render(0);
9708   DALI_TEST_CHECK( !actor.IsVisible() );
9709   Stage::GetCurrent().Add(actor);
9710
9711   // Start the animation
9712   float durationSeconds(10.0f);
9713   Animation animation = Animation::New(durationSeconds);
9714   animation.Show(actor, durationSeconds*0.5f);
9715   animation.Play();
9716
9717   bool signalReceived(false);
9718   AnimationFinishCheck finishCheck(signalReceived);
9719   animation.FinishedSignal().Connect(&application, finishCheck);
9720
9721   application.SendNotification();
9722   application.Render(static_cast<unsigned int>(durationSeconds*490.0f));
9723
9724   // We didn't expect the animation to finish yet
9725   application.SendNotification();
9726   finishCheck.CheckSignalNotReceived();
9727   DALI_TEST_CHECK( !actor.IsVisible() );
9728
9729   application.SendNotification();
9730   application.Render(static_cast<unsigned int>(durationSeconds*10.0f)/*Should be shown now*/);
9731
9732   // We didn't expect the animation to finish yet
9733   application.SendNotification();
9734   finishCheck.CheckSignalNotReceived();
9735   DALI_TEST_CHECK( actor.IsVisible() );
9736
9737   application.SendNotification();
9738   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
9739
9740   // We did expect the animation to finish
9741   application.SendNotification();
9742   finishCheck.CheckSignalReceived();
9743   DALI_TEST_CHECK( actor.IsVisible() );
9744   END_TEST;
9745 }
9746
9747 int UtcDaliAnimationHideP(void)
9748 {
9749   TestApplication application;
9750
9751   Actor actor = Actor::New();
9752   DALI_TEST_CHECK( actor.IsVisible() );
9753   Stage::GetCurrent().Add(actor);
9754
9755   // Start the animation
9756   float durationSeconds(10.0f);
9757   Animation animation = Animation::New(durationSeconds);
9758   animation.Hide(actor, durationSeconds*0.5f);
9759   animation.Play();
9760
9761   bool signalReceived(false);
9762   AnimationFinishCheck finishCheck(signalReceived);
9763   animation.FinishedSignal().Connect(&application, finishCheck);
9764
9765   application.SendNotification();
9766   application.Render(static_cast<unsigned int>(durationSeconds*490.0f));
9767
9768   // We didn't expect the animation to finish yet
9769   application.SendNotification();
9770   finishCheck.CheckSignalNotReceived();
9771   DALI_TEST_CHECK( actor.IsVisible() );
9772
9773   application.SendNotification();
9774   application.Render(static_cast<unsigned int>(durationSeconds*10.0f)/*Should be hidden now*/);
9775
9776   // We didn't expect the animation to finish yet
9777   application.SendNotification();
9778   finishCheck.CheckSignalNotReceived();
9779   DALI_TEST_CHECK( !actor.IsVisible() );
9780
9781   application.SendNotification();
9782   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
9783
9784   // We did expect the animation to finish
9785   application.SendNotification();
9786   finishCheck.CheckSignalReceived();
9787   DALI_TEST_CHECK( !actor.IsVisible() );
9788   END_TEST;
9789 }
9790
9791 int UtcDaliAnimationShowHideAtEndP(void)
9792 {
9793   // Test that show/hide delay can be the same as animation duration
9794   // i.e. to show/hide at the end of the animation
9795
9796   TestApplication application;
9797
9798   Actor actor = Actor::New();
9799   DALI_TEST_CHECK( actor.IsVisible() );
9800   Stage::GetCurrent().Add(actor);
9801
9802   // Start Hide animation
9803   float durationSeconds(10.0f);
9804   Animation animation = Animation::New(durationSeconds);
9805   animation.Hide(actor, durationSeconds/*Hide at end*/);
9806   animation.Play();
9807
9808   bool signalReceived(false);
9809   AnimationFinishCheck finishCheck(signalReceived);
9810   animation.FinishedSignal().Connect(&application, finishCheck);
9811
9812   application.SendNotification();
9813   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
9814
9815   // We did expect the animation to finish
9816   application.SendNotification();
9817   finishCheck.CheckSignalReceived();
9818   DALI_TEST_CHECK( !actor.IsVisible() );
9819
9820   // Start Show animation
9821   animation = Animation::New(durationSeconds);
9822   animation.Show(actor, durationSeconds/*Show at end*/);
9823   animation.FinishedSignal().Connect(&application, finishCheck);
9824   animation.Play();
9825
9826   application.SendNotification();
9827   application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
9828
9829   // We did expect the animation to finish
9830   application.SendNotification();
9831   finishCheck.CheckSignalReceived();
9832   DALI_TEST_CHECK( actor.IsVisible() );
9833   END_TEST;
9834 }
9835
9836 int UtcDaliKeyFramesCreateDestroyP(void)
9837 {
9838   tet_infoline("Testing Dali::Animation::UtcDaliKeyFramesCreateDestroy()");
9839
9840   KeyFrames* keyFrames = new KeyFrames;
9841   delete keyFrames;
9842   DALI_TEST_CHECK( true );
9843   END_TEST;
9844 }
9845
9846 int UtcDaliKeyFramesDownCastP(void)
9847 {
9848   TestApplication application;
9849   tet_infoline("Testing Dali::Animation::KeyFramesDownCast()");
9850
9851   KeyFrames keyFrames = KeyFrames::New();
9852   BaseHandle object(keyFrames);
9853
9854   KeyFrames keyFrames2 = KeyFrames::DownCast(object);
9855   DALI_TEST_CHECK(keyFrames2);
9856
9857   KeyFrames keyFrames3 = DownCast< KeyFrames >(object);
9858   DALI_TEST_CHECK(keyFrames3);
9859
9860   BaseHandle unInitializedObject;
9861   KeyFrames keyFrames4 = KeyFrames::DownCast(unInitializedObject);
9862   DALI_TEST_CHECK(!keyFrames4);
9863
9864   KeyFrames keyFrames5 = DownCast< KeyFrames >(unInitializedObject);
9865   DALI_TEST_CHECK(!keyFrames5);
9866   END_TEST;
9867 }
9868
9869 int UtcDaliAnimationCreateDestroyP(void)
9870 {
9871   TestApplication application;
9872   Animation* animation = new Animation;
9873   DALI_TEST_CHECK( animation );
9874   delete animation;
9875   END_TEST;
9876 }
9877
9878 struct UpdateManagerTestConstraint
9879 {
9880   UpdateManagerTestConstraint(TestApplication& application)
9881   : mApplication(application)
9882   {
9883   }
9884
9885   void operator()( Vector3& current, const PropertyInputContainer& /* inputs */)
9886   {
9887     mApplication.SendNotification();  // Process events
9888   }
9889
9890   TestApplication& mApplication;
9891 };
9892
9893 int UtcDaliAnimationUpdateManagerP(void)
9894 {
9895   TestApplication application;
9896
9897   Actor actor = Actor::New();
9898   Stage::GetCurrent().Add( actor );
9899
9900   // Build the animation
9901   Animation animation = Animation::New( 0.0f );
9902
9903   bool signalReceived = false;
9904   AnimationFinishCheck finishCheck( signalReceived );
9905   animation.FinishedSignal().Connect( &application, finishCheck );
9906
9907   Vector3 startValue(1.0f, 1.0f, 1.0f);
9908   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
9909   Constraint constraint = Constraint::New<Vector3>( actor, index, UpdateManagerTestConstraint( application ) );
9910   constraint.Apply();
9911
9912   // Apply animation to actor
9913   animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 100.f, 90.f, 80.f ), AlphaFunction::LINEAR );
9914   animation.AnimateTo( Property(actor, DevelActor::Property::OPACITY), 0.3f, AlphaFunction::LINEAR );
9915
9916   animation.Play();
9917
9918   application.SendNotification();
9919   application.UpdateOnly( 16 );
9920
9921   finishCheck.CheckSignalNotReceived();
9922
9923   application.SendNotification();   // Process events
9924
9925   finishCheck.CheckSignalReceived();
9926
9927   END_TEST;
9928 }
9929
9930 int UtcDaliAnimationSignalOrderP(void)
9931 {
9932   TestApplication application;
9933
9934   Actor actor = Actor::New();
9935   Stage::GetCurrent().Add( actor );
9936
9937   // Build the animations
9938   Animation animation1 = Animation::New( 0.0f ); // finishes first frame
9939   Animation animation2 = Animation::New( 0.02f ); // finishes in 20 ms
9940
9941   bool signal1Received = false;
9942   animation1.FinishedSignal().Connect( &application, AnimationFinishCheck( signal1Received ) );
9943
9944   bool signal2Received = false;
9945   animation2.FinishedSignal().Connect( &application, AnimationFinishCheck( signal2Received ) );
9946
9947   // Apply animations to actor
9948   animation1.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 3.0f, 2.0f, 1.0f ), AlphaFunction::LINEAR );
9949   animation1.Play();
9950   animation2.AnimateTo( Property(actor, Actor::Property::SIZE ), Vector3( 10.0f, 20.0f, 30.0f ), AlphaFunction::LINEAR );
9951   animation2.Play();
9952
9953   DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
9954   DALI_TEST_EQUALS( signal2Received, false, TEST_LOCATION );
9955
9956   application.SendNotification();
9957   application.UpdateOnly( 10 ); // 10ms progress
9958
9959   // no notifications yet
9960   DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
9961   DALI_TEST_EQUALS( signal2Received, false, TEST_LOCATION );
9962
9963   application.SendNotification();
9964
9965   // first completed
9966   DALI_TEST_EQUALS( signal1Received, true, TEST_LOCATION );
9967   DALI_TEST_EQUALS( signal2Received, false, TEST_LOCATION );
9968   signal1Received = false;
9969
9970   // 1st animation is complete now, do another update with no ProcessEvents in between
9971   application.UpdateOnly( 20 ); // 20ms progress
9972
9973   // ProcessEvents
9974   application.SendNotification();
9975
9976   // 2nd should complete now
9977   DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
9978   DALI_TEST_EQUALS( signal2Received, true, TEST_LOCATION );
9979
9980   END_TEST;
9981 }
9982
9983 int UtcDaliAnimationExtendDurationP(void)
9984 {
9985   TestApplication application;
9986
9987   Actor actor = Actor::New();
9988
9989   // Register a float property
9990   float startValue(10.0f);
9991   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
9992   Stage::GetCurrent().Add(actor);
9993   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
9994   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue, TEST_LOCATION );
9995
9996   // Build the animation
9997   float initialDurationSeconds(1.0f);
9998   float animatorDelay = 5.0f;
9999   float animatorDurationSeconds(5.0f);
10000   float extendedDurationSeconds(animatorDelay+animatorDurationSeconds);
10001   Animation animation = Animation::New(initialDurationSeconds);
10002   float targetValue(30.0f);
10003   float relativeValue(targetValue - startValue);
10004
10005   animation.AnimateTo(Property(actor, index),
10006                       targetValue,
10007                       TimePeriod(animatorDelay, animatorDurationSeconds));
10008
10009   // The duration should have been extended
10010   DALI_TEST_EQUALS( animation.GetDuration(), extendedDurationSeconds, TEST_LOCATION );
10011
10012   // Start the animation
10013   animation.Play();
10014
10015   bool signalReceived(false);
10016   AnimationFinishCheck finishCheck(signalReceived);
10017   animation.FinishedSignal().Connect(&application, finishCheck);
10018
10019   application.SendNotification();
10020   application.Render(static_cast<unsigned int>(extendedDurationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
10021
10022   // We didn't expect the animation to finish yet
10023   application.SendNotification();
10024   finishCheck.CheckSignalNotReceived();
10025   DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
10026
10027   application.SendNotification();
10028   application.Render(static_cast<unsigned int>(extendedDurationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
10029
10030   // We didn't expect the animation to finish yet
10031   application.SendNotification();
10032   finishCheck.CheckSignalNotReceived();
10033   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
10034
10035   application.SendNotification();
10036   application.Render(static_cast<unsigned int>(extendedDurationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
10037
10038   // We did expect the animation to finish
10039   application.SendNotification();
10040   finishCheck.CheckSignalReceived();
10041   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< float >( actor, index ), targetValue, TEST_LOCATION );
10042   END_TEST;
10043 }
10044
10045 int UtcDaliAnimationCustomIntProperty(void)
10046 {
10047   TestApplication application;
10048
10049   Actor actor = Actor::New();
10050   Stage::GetCurrent().Add(actor);
10051   int startValue(0u);
10052
10053   Property::Index index = actor.RegisterProperty("anIndex",  startValue);
10054   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), startValue, TEST_LOCATION );
10055
10056   // Build the animation
10057   float durationSeconds(1.0f);
10058   Animation animation = Animation::New(durationSeconds);
10059   animation.AnimateTo( Property(actor, index), 20 );
10060
10061   // Start the animation
10062   animation.Play();
10063
10064   bool signalReceived(false);
10065   AnimationFinishCheck finishCheck(signalReceived);
10066   animation.FinishedSignal().Connect(&application, finishCheck);
10067
10068   application.SendNotification();
10069   application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
10070
10071   // We didn't expect the animation to finish yet
10072   application.SendNotification();
10073   finishCheck.CheckSignalNotReceived();
10074   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), 10, TEST_LOCATION );
10075
10076   application.SendNotification();
10077   application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
10078
10079   // We did expect the animation to finish
10080   application.SendNotification();
10081   finishCheck.CheckSignalReceived();
10082   DALI_TEST_EQUALS( DevelHandle::GetCurrentProperty< int >( actor, index ), 20, TEST_LOCATION );
10083   END_TEST;
10084 }
10085
10086 int UtcDaliAnimationDuration(void)
10087 {
10088   TestApplication application;
10089
10090   Actor actor = Actor::New();
10091   Stage::GetCurrent().Add(actor);
10092
10093   Animation animation = Animation::New( 0.0f );
10094   DALI_TEST_EQUALS( 0.0f, animation.GetDuration(), TEST_LOCATION );
10095
10096   // The animation duration should automatically increase depending on the animator time period
10097
10098   animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 100.0f, TimePeriod( 0.0f, 1.0f ) );
10099   DALI_TEST_EQUALS( 1.0f, animation.GetDuration(), TEST_LOCATION );
10100
10101   animation.AnimateTo( Property( actor, Actor::Property::POSITION_Y ), 200.0f, TimePeriod( 10.0f, 1.0f ) );
10102   DALI_TEST_EQUALS( 11.0f, animation.GetDuration(), TEST_LOCATION );
10103
10104   END_TEST;
10105 }
10106
10107 int UtcDaliAnimationAnimateByNonAnimateableTypeN(void)
10108 {
10109   TestApplication application;
10110
10111   Actor actor = Actor::New();
10112
10113   // Register an integer property
10114   int startValue(1);
10115   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
10116   Stage::GetCurrent().Add(actor);
10117   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
10118
10119   try
10120   {
10121     // Build the animation
10122     Animation animation = Animation::New( 2.0f );
10123     std::string relativeValue = "relative string";
10124     animation.AnimateBy( Property(actor, index), relativeValue );
10125     tet_result(TET_FAIL);
10126   }
10127   catch ( Dali::DaliException& e )
10128   {
10129     DALI_TEST_ASSERT( e, "Animated value and Property type don't match", TEST_LOCATION );
10130   }
10131
10132
10133   END_TEST;
10134 }
10135
10136
10137 int UtcDaliAnimationAnimateToNonAnimateableTypeN(void)
10138 {
10139   TestApplication application;
10140
10141   Actor actor = Actor::New();
10142
10143   // Register an integer property
10144   int startValue(1);
10145   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
10146   Stage::GetCurrent().Add(actor);
10147   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
10148
10149   try
10150   {
10151     // Build the animation
10152     Animation animation = Animation::New( 2.0f );
10153     std::string relativeValue = "relative string";
10154     animation.AnimateTo( Property(actor, index), relativeValue );
10155
10156     tet_result(TET_FAIL);
10157   }
10158   catch ( Dali::DaliException& e )
10159   {
10160    DALI_TEST_ASSERT( e, "Animated value and Property type don't match", TEST_LOCATION );
10161   }
10162
10163   END_TEST;
10164 }
10165
10166 int UtcDaliAnimationAnimateBetweenNonAnimateableTypeN(void)
10167 {
10168   TestApplication application;
10169
10170   Actor actor = Actor::New();
10171
10172   // Register an integer property
10173   int startValue(1);
10174   Property::Index index = actor.RegisterProperty( "testProperty",  startValue );
10175   Stage::GetCurrent().Add(actor);
10176   DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
10177
10178   try
10179   {
10180     // Build the animation
10181     KeyFrames keyFrames = KeyFrames::New();
10182     keyFrames.Add( 0.0f, std::string("relative string1") );
10183     keyFrames.Add( 1.0f, std::string("relative string2") );
10184     // no need to really create the animation as keyframes do the check
10185
10186     tet_result(TET_FAIL);
10187   }
10188   catch ( Dali::DaliException& e )
10189   {
10190     DALI_TEST_ASSERT( e, "Type not animateable", TEST_LOCATION );
10191   }
10192
10193   END_TEST;
10194 }
10195
10196 int UtcDaliAnimationSetAndGetTargetBeforePlayP(void)
10197 {
10198   tet_infoline("Setting up an animation should not effect it's position property until the animation plays");
10199
10200   TestApplication application;
10201
10202   tet_infoline("Set initial position and set up animation to re-position actor");
10203
10204   Actor actor = Actor::New();
10205   Stage::GetCurrent().Add(actor);
10206   Vector3 initialPosition(0.0f, 0.0f, 0.0f);
10207   actor.SetProperty( Actor::Property::POSITION, initialPosition );
10208
10209   // Build the animation
10210   Animation animation = Animation::New(2.0f);
10211
10212   //Test GetCurrentProgress return 0.0 as the duration is 0.0
10213   DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
10214   DALI_TEST_EQUALS( Vector3( 0.0f, 0.0f, 0.0f ), actor.GetCurrentPosition(), TEST_LOCATION );
10215
10216   tet_infoline("Set target position in animation without intiating play");
10217
10218   Vector3 targetPosition(100.0f, 100.0f, 100.0f);
10219   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
10220
10221   application.SendNotification();
10222   application.Render();
10223
10224   tet_infoline("Ensure position of actor is still at intial value");
10225
10226   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), initialPosition.x, TEST_LOCATION );
10227   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), initialPosition.y, TEST_LOCATION );
10228   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), initialPosition.z, TEST_LOCATION );
10229
10230   tet_infoline("Play animation and ensure actor position is now target");
10231
10232   animation.Play();
10233   application.SendNotification();
10234   application.Render(1000u);
10235
10236   tet_infoline("Ensure position of actor is at target value when aninmation half way");
10237
10238   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPosition.x, TEST_LOCATION );
10239   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPosition.y, TEST_LOCATION );
10240   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPosition.z, TEST_LOCATION );
10241
10242   tet_printf( "x position at half way point(%f)\n", actor.GetCurrentPosition().x );
10243
10244   application.Render(2000u);
10245
10246   tet_infoline("Ensure position of actor is still at target value when aninmation complete");
10247
10248   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPosition.x, TEST_LOCATION );
10249   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPosition.y, TEST_LOCATION );
10250   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPosition.z, TEST_LOCATION );
10251
10252   END_TEST;
10253 }
10254
10255 int UtcDaliAnimationSetAndGetTargetBeforePlayMulitpleAnimatorsPositionP(void)
10256 {
10257   tet_infoline("Setting up an animation should not effect it's position property until the animation plays even with mulitple animators");
10258
10259   TestApplication application;
10260
10261   std::vector<Vector3> targetPositions;
10262
10263   targetPositions.push_back( Vector3( 100.0f, 100.0f, 100.0f ) );
10264   targetPositions.push_back( Vector3( 200.0f, 1.0f, 100.0f ) );
10265   targetPositions.push_back( Vector3( 50.0f, 10.0f, 100.0f ) );
10266
10267   tet_infoline("Set initial position and set up animation to re-position actor");
10268
10269   Actor actor = Actor::New();
10270   Stage::GetCurrent().Add(actor);
10271   Vector3 initialPosition(0.0f, 0.0f, 0.0f);
10272   actor.SetProperty( Actor::Property::POSITION, initialPosition );
10273
10274   // Build the animation
10275   Animation animation = Animation::New(2.0f);
10276
10277   //Test GetCurrentProgress return 0.0 as the duration is 0.0
10278   DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
10279   DALI_TEST_EQUALS( Vector3( 0.0f, 0.0f, 0.0f ), actor.GetCurrentPosition(), TEST_LOCATION );
10280
10281   tet_infoline("Set target position in animation without intiating play");
10282
10283   for ( unsigned int i = 0; i < targetPositions.size(); i++ )
10284   {
10285     animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPositions[i], AlphaFunction::LINEAR);
10286   }
10287
10288   application.SendNotification();
10289   application.Render();
10290
10291   tet_infoline("Ensure position of actor is still at intial value");
10292
10293   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), initialPosition.x, TEST_LOCATION );
10294   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), initialPosition.y, TEST_LOCATION );
10295   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), initialPosition.z, TEST_LOCATION );
10296
10297   tet_infoline("Play animation and ensure actor position is now target");
10298
10299   animation.Play();
10300   application.SendNotification();
10301   application.Render(1000u);
10302
10303   tet_infoline("Ensure position of actor is at target value when aninmation half way");
10304
10305   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[2].x, TEST_LOCATION );
10306   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[2].y, TEST_LOCATION );
10307   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[2].z, TEST_LOCATION );
10308
10309   tet_printf( "x position at half way point(%f)\n", actor.GetCurrentPosition().x );
10310
10311   application.Render(2000u);
10312
10313   tet_infoline("Ensure position of actor is still at target value when aninmation complete");
10314
10315   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[2].x, TEST_LOCATION );
10316   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[2].y, TEST_LOCATION );
10317   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[2].z, TEST_LOCATION );
10318
10319   END_TEST;
10320 }
10321
10322 int UtcDaliAnimationSetAndGetTargetBeforePlayMulitpleAnimatorsSizeAndPositionP(void)
10323 {
10324   tet_infoline("Setting up an animation should not effect it's size property until the animation plays even with mulitple animators of different Property Indexes");
10325
10326   TestApplication application;
10327
10328   std::vector<Vector3> targetSizes;
10329   std::vector<Vector3> targetPositions;
10330
10331   targetSizes.push_back( Vector3( 100.0f, 100.0f, 100.0f ) );
10332   targetSizes.push_back( Vector3( 50.0f, 10.0f, 100.0f ) );
10333
10334   targetPositions.push_back( Vector3( 200.0f, 1.0f, 100.0f ) );
10335
10336   tet_infoline("Set initial position and set up animation to re-position actor");
10337
10338   Actor actor = Actor::New();
10339   Stage::GetCurrent().Add(actor);
10340   Vector3 initialSize( 10.0f, 10.0f, 10.0f);
10341   Vector3 initialPosition(10.0f, 10.0f, 10.0f);
10342
10343   actor.SetProperty( Actor::Property::SIZE, initialSize );
10344   actor.SetProperty( Actor::Property::POSITION, initialPosition );
10345
10346   // Build the animation
10347   Animation animation = Animation::New(2.0f);
10348
10349   tet_infoline("Set target size in animation without intiating play");
10350   animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSizes[0], AlphaFunction::LINEAR);
10351   tet_infoline("Set target position in animation without intiating play");
10352   animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPositions[0], AlphaFunction::LINEAR);
10353   animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSizes[1], AlphaFunction::LINEAR);
10354
10355   application.SendNotification();
10356   application.Render();
10357
10358   tet_infoline("Ensure position of actor is still at intial size and position");
10359
10360   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialSize.x, TEST_LOCATION );
10361   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialSize.y, TEST_LOCATION );
10362   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialSize.z, TEST_LOCATION );
10363
10364   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialPosition.x, TEST_LOCATION );
10365   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialPosition.y, TEST_LOCATION );
10366   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialPosition.z, TEST_LOCATION );
10367
10368   tet_infoline("Play animation and ensure actor position and size is now matches targets");
10369
10370   animation.Play();
10371   application.SendNotification();
10372   application.Render(2000u);
10373
10374   tet_infoline("Ensure position and size of actor is at target value when aninmation playing");
10375
10376   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSizes[1].x, TEST_LOCATION );
10377   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSizes[1].y, TEST_LOCATION );
10378   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSizes[1].z, TEST_LOCATION );
10379
10380   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[0].x, TEST_LOCATION );
10381   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[0].y, TEST_LOCATION );
10382   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[0].z, TEST_LOCATION );
10383
10384   END_TEST;
10385 }
10386
10387 int UtcDaliAnimationSetAndGetTargetBeforePlayMulitpleAnimatorsSizeAndPositionColourP(void)
10388 {
10389   tet_infoline("Setting up an animation should not effect it's size property until the animation plays even if other Properties animated");
10390
10391   TestApplication application;
10392
10393   std::vector<Vector3> targetSizes;
10394   std::vector<float> targetColors;
10395
10396   targetSizes.push_back( Vector3( 100.0f, 100.0f, 100.0f ) );
10397   targetSizes.push_back( Vector3( 50.0f, 10.0f, 150.0f ) );
10398
10399   targetColors.push_back( 1.0f );
10400
10401   tet_infoline("Set initial position and set up animation to re-position actor");
10402
10403   Actor actor = Actor::New();
10404   Stage::GetCurrent().Add(actor);
10405   Vector3 initialSize( 10.0f, 5.0f, 10.0f);
10406
10407   actor.SetProperty( Actor::Property::SIZE, initialSize );
10408
10409   // Build the animation
10410   Animation animation = Animation::New(2.0f);
10411
10412   tet_infoline("Set target size in animation without intiating play");
10413   animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSizes[0], AlphaFunction::LINEAR);
10414   tet_infoline("Set target position in animation without intiating play");
10415   animation.AnimateTo(Property(actor, Actor::Property::COLOR_RED), targetColors[0], AlphaFunction::LINEAR);
10416   animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSizes[1], AlphaFunction::LINEAR);
10417
10418   application.SendNotification();
10419   application.Render();
10420
10421   tet_infoline("Ensure position of actor is still at intial size and position");
10422
10423   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialSize.x, TEST_LOCATION );
10424   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialSize.y, TEST_LOCATION );
10425   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialSize.z, TEST_LOCATION );
10426
10427   tet_infoline("Play animation and ensure actor position and size is now matches targets");
10428
10429   animation.Play();
10430   application.SendNotification();
10431   application.Render(2000u);
10432
10433   tet_infoline("Ensure position and size of actor is at target value when aninmation playing");
10434
10435   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSizes[1].x, TEST_LOCATION );
10436   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSizes[1].y, TEST_LOCATION );
10437   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSizes[1].z, TEST_LOCATION );
10438
10439   DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), targetColors[0], TEST_LOCATION );
10440
10441   END_TEST;
10442 }