+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
+
+ // We did expect the animation to finish
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of Timeperiod in seconds
+
+ // Check that nothing has changed after a couple of buffer swaps
+ application.Render(0);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0, 0.0, 0.0), TEST_LOCATION);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayAfterP2(void)
+{
+ TestApplication application;
+
+ tet_printf("Testing that playing after 2 seconds before looping\n");
+
+ {
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetLooping(true);
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR, TimePeriod(0.5f, 0.5f));
+
+ // Play animation after the initial delay time
+ animation.PlayAfter(0.2f);
+ application.SendNotification();
+ application.Render(0); // start animation
+
+ for(int iterations = 0; iterations < 3; ++iterations)
+ {
+ // The initial delay time of PlayAfter() applies only once in looping mode.
+ if(iterations == 0)
+ {
+ application.Render(durationSeconds * 200.f); // The intial delay time of PlayAfter
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move
+ }
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
+
+ // We didn't expect the animation to finish yet
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in seconds
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
+
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.5f), TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% progress */);
+
+ // We did expect the animation to finish
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ }
+
+ animation.SetLooping(false);
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
+
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ }
+
+ tet_printf("Testing that playing after 2 seconds before looping with negative speedfactor\n");
+ // SpeedFactor < 0
+ {
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetLooping(true);
+ animation.SetSpeedFactor(-1.0f); //Set SpeedFactor as < 0
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR, TimePeriod(0.5f, 0.5f));
+
+ // Play animation after the initial delay time
+ animation.PlayAfter(0.2f);
+ application.SendNotification();
+ application.Render(0); // start animation
+
+ for(int iterations = 0; iterations < 3; ++iterations)
+ {
+ // The initial delay time of PlayAfter() applies only once in looping mode.
+ if(iterations == 0)
+ {
+ application.Render(durationSeconds * 200.f); // The intial delay time of PlayAfter
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 1.0f), TEST_LOCATION); // Not move. NOTE SpeedFactor < 0 so 'targetPosition' is start position.
+ }
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% animation progress, 50% animator progress */);
+
+ // We didn't expect the animation to finish yet
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.5f), TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% animation progress, 100% animator progress */);
+
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 100% progress */);
+
+ // We did expect the animation to finish
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in second
+ }
+
+ animation.SetLooping(false);
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
+
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0, 0.0, 0.0), TEST_LOCATION);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayAfterP3(void)
+{
+ TestApplication application;
+
+ tet_printf("Testing that PlayAfter with the negative delay seconds\n");
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR, TimePeriod(0.5f, 0.5f));
+
+ // When the delay time is negative value, it would treat as play immediately.
+ animation.PlayAfter(-2.0f);
+ application.SendNotification();
+ application.Render(0); // start animation
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
+
+ // We didn't expect the animation to finish yet
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in seconds
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
+
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.5f), TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
+
+ // We did expect the animation to finish
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+
+ // Check that nothing has changed after a couple of buffer swaps
+ application.Render(0);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayAfterP4(void)
+{
+ TestApplication application;
+
+ tet_printf("Testing that PlayAfter with progress value\n");
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR, TimePeriod(0.5f, 0.5f));
+
+ // Delay time is 0.3s. So after duration times, progress must be 70%. animation will finished at 1.3s.
+ animation.PlayAfter(durationSeconds * 0.3f);
+ application.SendNotification();
+ application.Render(0); // start animation
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 5/6 delay progress, 0% animation progress, 0% animator progress */);
+
+ // We didn't expect the animation to finish yet
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of PlayAfter
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% delay progress, 20% animation progress, 0% animator progress */);
+
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in seconds
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% delay progress, 45% animation progress, 0% animator progress */);
+
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in seconds
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% delay progress, 70% animation progress, 40% animator progress */);
+
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.4f), TEST_LOCATION); // 40% of animator progress
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% delay progress, 95% animation progress, 90% animator progress */);
+
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.9f), TEST_LOCATION); // 90% of animator progress
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
+
+ // We did expect the animation to finish
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+
+ // Check that nothing has changed after a couple of buffer swaps
+ application.Render(0);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ END_TEST;
+}
+
+int UtcDaliAnimationSetLoopingModeP(void)
+{
+ // Test Loop forever and Loop mode being set
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
+
+ // Default: LoopingMode::RESTART
+ {
+ Actor actor = Actor::New();
+ stage.Add(actor);
+
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::RESTART);
+
+ Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
+
+ // Start the animation
+ animation.Play();
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /*Only half the animation*/);
+
+ actor.Unparent();
+
+ application.SendNotification();
+ application.Render();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ }
+
+ // LoopingMode::AUTO_REVERSE
+ {
+ Actor actor = Actor::New();
+ stage.Add(actor);
+
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetLooping(true);
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
+
+ animation.SetLoopingMode(Animation::LoopingMode::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
+
+ // Start the animation
+ animation.Play();
+ application.SendNotification();
+ application.Render(0);
+
+ for(int iterations = 0; iterations < 3; ++iterations)
+ {
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% time progress */);
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+
+ // AUTO_REVERSE mode means, for Animation duration time, the actor starts from the beginning, passes the targetPosition,
+ // and arrives at the beginning.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 100% time progress */);
+
+ // We did expect the animation to finish
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
+ }
+
+ animation.SetLooping(false);
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
+
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
+ }
+
+ // LoopingMode::AUTO_REVERSE in Reverse mode, which begin from the end
+ {
+ Actor actor = Actor::New();
+ stage.Add(actor);
+
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetLooping(true);
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+ application.SendNotification();
+
+ // Specify a negative multiplier to play the animation in reverse
+ animation.SetSpeedFactor(-1.0f);
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
+
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
+
+ // Start the animation
+ animation.Play();
+ application.SendNotification();
+ application.Render(0);
+
+ for(int iterations = 0; iterations < 3; ++iterations)
+ {
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% time progress */);
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+
+ // Setting a negative speed factor is to play the animation in reverse.
+ // So, when LoopingMode::AUTO_REVERSE and SetSpeedFactor( -1.0f ) is, for Animation duration time,
+ // the actor starts from the targetPosition, passes the beginning, and arrives at the targetPosition.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 100% time progress */);
+
+ // We did expect the animation to finish
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ }
+
+ animation.SetLooping(false);
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
+
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliAnimationSetLoopingModeP2(void)
+{
+ // Test Loop Count and Loop mode being set
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
+
+ // LoopingMode::AUTO_REVERSE
+ {
+ Actor actor = Actor::New();
+ stage.Add(actor);
+
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetLoopCount(3);
+ DALI_TEST_CHECK(animation.IsLooping());
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
+
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
+
+ // Start the animation
+ animation.Play();
+
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+
+ // Loop
+ float intervalSeconds = 3.0f;
+
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ // AUTO_REVERSE mode means, for Animation duration time, the actor starts from the beginning, passes the targetPosition,
+ // and arrives at the beginning.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
+
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
+
+ finishCheck.Reset();
+ }
+
+ // LoopingMode::AUTO_REVERSE in Reverse mode, which begin from the end
+ {
+ Actor actor = Actor::New();
+ stage.Add(actor);
+
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetLoopCount(3);
+ DALI_TEST_CHECK(animation.IsLooping());
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+ application.SendNotification();
+
+ // Specify a negative multiplier to play the animation in reverse
+ animation.SetSpeedFactor(-1.0f);
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
+
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
+
+ // Start the animation
+ animation.Play();
+
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+
+ // Loop
+ float intervalSeconds = 3.0f;
+
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ // Setting a negative speed factor is to play the animation in reverse.
+ // So, when LoopingMode::AUTO_REVERSE and SetSpeedFactor( -1.0f ) is, for Animation duration time,
+ // the actor starts from the targetPosition, passes the beginning, and arrives at the targetPosition.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+
+ finishCheck.Reset();
+ }
+
+ END_TEST;
+}
+
+int UtcDaliAnimationSetLoopingModeP3(void)
+{
+ // Test Loop Count is 1 (== default) and Loop mode being set
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
+
+ // LoopingMode::AUTO_REVERSE
+ {
+ Actor actor = Actor::New();
+ stage.Add(actor);
+
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ DALI_TEST_CHECK(1 == animation.GetLoopCount());
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
+
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
+
+ // Start the animation
+ animation.Play();
+ application.Render(0);
+ application.SendNotification();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /* 50% time progress */);
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+
+ // AUTO_REVERSE mode means, for Animation duration time, the actor starts from the beginning, passes the targetPosition,
+ // and arrives at the beginning.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /* 100% time progress */);
+
+ application.SendNotification();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 1.0f * 1000.0f) + 1u /*just beyond the animation duration*/);
+
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+
+ // After all animation finished, arrives at the beginning.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
+
+ finishCheck.Reset();
+ }
+
+ // LoopingMode::AUTO_REVERSE in Reverse mode, which begin from the end
+ {
+ Actor actor = Actor::New();
+ stage.Add(actor);
+
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ DALI_TEST_CHECK(1 == animation.GetLoopCount());
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+ application.SendNotification();
+
+ // Specify a negative multiplier to play the animation in reverse
+ animation.SetSpeedFactor(-1.0f);
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
+
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
+
+ // Start the animation
+ animation.Play();
+ application.Render(0);
+ application.SendNotification();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /* 50% time progress */);
+ application.SendNotification();
+ finishCheck.CheckSignalNotReceived();
+
+ // Setting a negative speed factor is to play the animation in reverse.
+ // So, when LoopingMode::AUTO_REVERSE and SetSpeedFactor( -1.0f ) is, for Animation duration time,
+ // the actor starts from the targetPosition, passes the beginning, and arrives at the targetPosition.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /* 100% time progress */);
+
+ application.SendNotification();
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 1.0f * 1000.0f) + 1u /*just beyond the animation duration*/);
+
+ application.SendNotification();
+ application.Render(0);
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+
+ // After all animation finished, arrives at the target.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+
+ finishCheck.Reset();
+ }
+
+ END_TEST;
+}
+
+int UtcDaliAnimationGetLoopingModeP(void)
+{
+ TestApplication application;
+
+ Animation animation = Animation::New(1.0f);
+
+ // default mode
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::RESTART);
+
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
+
+ END_TEST;
+}
+
+int UtcDaliAnimationProgressSignalConnectionWithoutProgressMarkerP(void)
+{
+ TestApplication application;
+
+ tet_infoline("Connect to ProgressReachedSignal but do not set a required Progress marker");
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animation = Animation::New(0.0f);
+
+ //Set duration
+ float durationSeconds(1.0f);
+ animation.SetDuration(durationSeconds);
+
+ bool finishedSignalReceived(false);
+ bool progressSignalReceived(false);
+
+ AnimationFinishCheck finishCheck(finishedSignalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+
+ AnimationProgressCheck progressCheck(progressSignalReceived);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ progressCheck.CheckSignalNotReceived();
+
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 100.0f); // 10% progress
+ application.SendNotification();
+
+ tet_infoline("Ensure after animation has started playing that ProgressReachedSignal not emitted");
+ progressCheck.CheckSignalNotReceived();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 900.0f) + 1u /*just beyond the animation duration*/);
+
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+ tet_infoline("Animation finished");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliAnimationMultipleProgressSignalsP(void)
+{
+ tet_infoline("Multiple animations with different progress markers");
+
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animationAlpha = Animation::New(0.0f);
+ Animation animationBeta = Animation::New(0.0f);
+
+ //Set duration
+ float durationSeconds(1.0f);
+ animationAlpha.SetDuration(durationSeconds);
+ animationBeta.SetDuration(durationSeconds);
+
+ bool progressSignalReceivedAlpha(false);
+ bool progressSignalReceivedBeta(false);
+
+ AnimationProgressCheck progressCheckAlpha(progressSignalReceivedAlpha, "animation:Alpha");
+ AnimationProgressCheck progressCheckBeta(progressSignalReceivedBeta, "animation:Beta");
+
+ DevelAnimation::ProgressReachedSignal(animationAlpha).Connect(&application, progressCheckAlpha);
+ DevelAnimation::ProgressReachedSignal(animationBeta).Connect(&application, progressCheckBeta);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animationAlpha.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+ animationBeta.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ tet_infoline("AnimationAlpha Progress notification set to 30%");
+ DevelAnimation::SetProgressNotification(animationAlpha, 0.3f);
+
+ tet_infoline("AnimationBeta Progress notification set to 50%");
+ DevelAnimation::SetProgressNotification(animationBeta, 0.5f);
+
+ application.SendNotification();
+ application.Render();
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ // Start the animations from 10% progress
+ animationAlpha.SetCurrentProgress(0.1f);
+ animationBeta.SetCurrentProgress(0.1f);
+ animationAlpha.Play();
+ animationBeta.Play();
+
+ tet_infoline("Animation Playing from 10%");
+
+ application.SendNotification();
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 100.0f); // 20% progress
+
+ tet_infoline("Animation at 20% - No signals to be received");
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 200.0f); // 40% progress
+ application.SendNotification();
+ tet_infoline("Animation at 40% - Alpha signal should be received");
+ DALI_TEST_EQUALS(0.4f, animationAlpha.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheckAlpha.CheckSignalReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheckAlpha.Reset();
+ progressCheckBeta.Reset();
+
+ application.Render(durationSeconds * 100.0f); // 50% progress
+ tet_infoline("Animation at 50% - Beta should receive signal, Alpha should not");
+ application.SendNotification();
+
+ DALI_TEST_EQUALS(0.5f, animationBeta.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalReceived();
+ tet_infoline("Progress check reset");
+ progressCheckAlpha.Reset();
+ progressCheckBeta.Reset();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 60% progress */);
+ application.SendNotification();
+
+ tet_infoline("Animation at 60%");
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
+ application.SendNotification();
+ tet_infoline("Animation at 80%");
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
+ // We did expect the animation to finish
+ tet_infoline("Animation finished");
+
+ END_TEST;
+}
+
+int UtcDaliAnimationMultipleProgressSignalsP2(void)
+{
+ tet_infoline("Multiple animations with different progress markers and big step time");
+
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animationAlpha = Animation::New(0.0f);
+ Animation animationBeta = Animation::New(0.0f);
+
+ //Set duration
+ const float durationSeconds(1.0f);
+ animationAlpha.SetDuration(durationSeconds);
+ animationBeta.SetDuration(durationSeconds);
+
+ bool progressSignalReceivedAlpha(false);
+ bool progressSignalReceivedBeta(false);
+
+ AnimationProgressCheck progressCheckAlpha(progressSignalReceivedAlpha, "animation:Alpha");
+ AnimationProgressCheck progressCheckBeta(progressSignalReceivedBeta, "animation:Beta");
+
+ DevelAnimation::ProgressReachedSignal(animationAlpha).Connect(&application, progressCheckAlpha);
+ DevelAnimation::ProgressReachedSignal(animationBeta).Connect(&application, progressCheckBeta);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animationAlpha.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+ animationBeta.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ tet_infoline("AnimationAlpha Progress notification set to 1%");
+ DevelAnimation::SetProgressNotification(animationAlpha, 0.01f);
+
+ tet_infoline("AnimationBeta Progress notification set to 99%");
+ DevelAnimation::SetProgressNotification(animationBeta, 0.99f);
+
+ application.SendNotification();
+ application.Render();
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ // Start the animations unlimited looping
+ animationAlpha.SetLooping(true);
+ animationBeta.SetLooping(true);
+ animationAlpha.Play();
+ animationBeta.Play();
+
+ application.SendNotification();
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 20.0f); // 2% progress
+ application.SendNotification();
+ DALI_TEST_EQUALS(0.02f, animationAlpha.GetCurrentProgress(), TEST_LOCATION);
+
+ tet_infoline("Animation at 2% - Alpha signals should be received, Beta should not.");
+
+ progressCheckAlpha.CheckSignalReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheckAlpha.Reset();
+ progressCheckBeta.Reset();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 960.0f); // 98% progress
+ application.SendNotification();
+ tet_infoline("Animation at 98% - No signal received");
+ DALI_TEST_EQUALS(0.98f, animationAlpha.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 40.0f); // 2% progress
+ application.SendNotification();
+ tet_infoline("Animation loop once and now 2% - Alpha and Beta should receive signal");
+ application.SendNotification();
+
+ DALI_TEST_EQUALS(0.02f, animationBeta.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheckAlpha.CheckSignalReceived();
+ progressCheckBeta.CheckSignalReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheckAlpha.Reset();
+ progressCheckBeta.Reset();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 980.0f); // 100% progress
+ application.SendNotification();
+ tet_infoline("Animation loop one more time. and now 100% - Beta should receive signal, Alhpa sholud not");
+ application.SendNotification();
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheckAlpha.Reset();
+ progressCheckBeta.Reset();
+
+ animationAlpha.SetLooping(false);
+ animationBeta.SetLooping(false);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 2000.0f) + 1u /*just beyond the animation duration*/);
+ application.SendNotification();
+
+ // We did expect the animation to finish
+ tet_infoline("Animation finished");
+
+ END_TEST;
+}
+
+int UtcDaliAnimationProgressSignalWithPlayAfterP(void)
+{
+ tet_infoline("Multiple animations with different progress markers");
+
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animationAlpha = Animation::New(0.0f);
+ Animation animationBeta = Animation::New(0.0f);
+
+ //Set duration
+ float durationSeconds(1.0f);
+ float delaySeconds(0.5f);
+ animationAlpha.SetDuration(durationSeconds);
+ animationBeta.SetDuration(durationSeconds);
+
+ bool progressSignalReceivedAlpha(false);
+ bool progressSignalReceivedBeta(false);
+
+ AnimationProgressCheck progressCheckAlpha(progressSignalReceivedAlpha, "animation:Alpha");
+ AnimationProgressCheck progressCheckBeta(progressSignalReceivedBeta, "animation:Beta");
+
+ DevelAnimation::ProgressReachedSignal(animationAlpha).Connect(&application, progressCheckAlpha);
+ DevelAnimation::ProgressReachedSignal(animationBeta).Connect(&application, progressCheckBeta);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animationAlpha.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+ animationBeta.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ tet_infoline("AnimationAlpha Progress notification set to 30%");
+ DevelAnimation::SetProgressNotification(animationAlpha, 0.3f);
+
+ tet_infoline("AnimationBeta Progress notification set to ~0% (==Notify when delay is done)");
+ DevelAnimation::SetProgressNotification(animationBeta, Math::MACHINE_EPSILON_1);
+
+ application.SendNotification();
+ application.Render();
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ // Start the animations from 10% progress
+ animationAlpha.PlayAfter(delaySeconds);
+ animationBeta.PlayAfter(delaySeconds);
+
+ application.SendNotification();
+ application.Render(0); // start animation
+ application.Render(delaySeconds * 500.0f); // 50% wait progress
+
+ tet_infoline("Delay at 50% - No signals to be received");
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(delaySeconds * 500.0f + durationSeconds * 50.0f); // 100% wait, 5% progress
+ application.SendNotification();
+ tet_infoline("Delay at 100%, Animation at 5% - Beta signal should be received");
+ DALI_TEST_EQUALS(0.05f, animationBeta.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheckBeta.CheckSignalReceived();
+ progressCheckAlpha.CheckSignalNotReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheckAlpha.Reset();
+ progressCheckBeta.Reset();
+
+ application.Render(durationSeconds * 200.0f); // 25% progress
+ tet_infoline("Animation at 25% - No signals to be received");
+ application.SendNotification();
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ application.Render(durationSeconds * 200.0f); // 45% progress
+ tet_infoline("Animation at 45% - Alpha should receive signal, Beta should not");
+ application.SendNotification();
+
+ DALI_TEST_EQUALS(0.45f, animationAlpha.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheckAlpha.CheckSignalReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheckAlpha.Reset();
+ progressCheckBeta.Reset();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 150.0f) /* 60% progress */);
+ application.SendNotification();
+
+ tet_infoline("Animation at 60%");
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
+ application.SendNotification();
+ tet_infoline("Animation at 80%");
+
+ progressCheckAlpha.CheckSignalNotReceived();
+ progressCheckBeta.CheckSignalNotReceived();
+
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
+ // We did expect the animation to finish
+ tet_infoline("Animation finished");
+
+ END_TEST;
+}
+
+int UtcDaliAnimationProgressCallbackWithLoopingP(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animation = Animation::New(0.0f);
+
+ //Set duration
+ const float durationSeconds(1.0f);
+ animation.SetDuration(durationSeconds);
+
+ // Set Looping Count
+ const int loopCount(4);
+ animation.SetLoopCount(loopCount);
+
+ bool finishedSignalReceived(false);
+ bool progressSignalReceived(false);
+
+ AnimationFinishCheck finishCheck(finishedSignalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+
+ AnimationProgressCheck progressCheck(progressSignalReceived);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ tet_infoline("Animation Progress notification set to 50% with looping count 4");
+ DevelAnimation::SetProgressNotification(animation, 0.5f);
+
+ application.SendNotification();
+ application.Render();
+
+ progressCheck.CheckSignalNotReceived();
+
+ animation.Play();
+
+ for(int count = 0; count < loopCount; count++)
+ {
+ application.SendNotification();
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 25% progress
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ tet_infoline("Animation at 25%");
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 50% progress
+ application.SendNotification();
+ tet_infoline("Animation at 50%");
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheck.Reset();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 75% progress
+ tet_infoline("Animation at 75%");
+ application.SendNotification();
+
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 100% progress
+ tet_infoline("Animation at 100%");
+ application.SendNotification();
+
+ //Nothing check at 100% progress. cause It can be both 100% and 0%.
+ application.SendNotification();
+ }
+ application.Render(10u);
+ application.SendNotification();
+ application.Render(0u);
+ application.SendNotification();
+
+ finishCheck.CheckSignalReceived();
+
+ END_TEST;
+}
+
+int UtcDaliAnimationProgressCallbackWithLoopingP2(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animation = Animation::New(0.0f);
+
+ //Set duration
+ const float durationSeconds(1.0f);
+ animation.SetDuration(durationSeconds);
+
+ // Set Looping Unlmited
+ animation.SetLooping(true);
+
+ bool finishedSignalReceived(false);
+ bool progressSignalReceived(false);
+
+ AnimationFinishCheck finishCheck(finishedSignalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+
+ AnimationProgressCheck progressCheck(progressSignalReceived);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ tet_infoline("Animation Progress notification set to 50% with unlimited looping");
+ DevelAnimation::SetProgressNotification(animation, 0.5f);
+
+ application.SendNotification();
+ application.Render();
+
+ progressCheck.CheckSignalNotReceived();
+
+ animation.Play();
+
+ for(int count = 0; count < 4; count++)
+ {
+ application.SendNotification();
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 25% progress
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ tet_infoline("Animation at 25%");
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 50% progress
+ application.SendNotification();
+ tet_infoline("Animation at 50%");
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheck.Reset();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 75% progress
+ tet_infoline("Animation at 75%");
+ application.SendNotification();
+
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 100% progress
+ tet_infoline("Animation at 100%");
+ application.SendNotification();
+
+ //Nothing check at 100% progress. cause It can be both 100% and 0%.
+ finishCheck.CheckSignalNotReceived();
+ application.SendNotification();
+ }
+ finishCheck.CheckSignalNotReceived();
+
+ animation.SetLooping(false);
+ application.Render(0u);
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 10u);
+ application.SendNotification();
+ application.Render(0u);
+ application.SendNotification();
+
+ finishCheck.CheckSignalReceived();
+
+ END_TEST;
+}
+
+int UtcDaliAnimationProgressCallbackNegativeSpeed(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animation = Animation::New(0.0f);
+
+ //Set duration
+ const float durationSeconds(1.0f);
+ animation.SetDuration(durationSeconds);
+
+ //Set speed negative
+ animation.SetSpeedFactor(-1.0f);
+
+ // Set Looping Unlmited
+ animation.SetLooping(true);
+
+ bool finishedSignalReceived(false);
+ bool progressSignalReceived(false);
+
+ AnimationFinishCheck finishCheck(finishedSignalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+
+ AnimationProgressCheck progressCheck(progressSignalReceived);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ tet_infoline("Animation Progress notification set to 50%");
+ DevelAnimation::SetProgressNotification(animation, 0.5f);
+
+ application.SendNotification();
+ application.Render();
+
+ progressCheck.CheckSignalNotReceived();
+
+ animation.Play();
+
+ for(int count = 0; count < 4; count++)
+ {
+ application.SendNotification();
+ application.Render(0); // start animation
+ progressCheck.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 25% progress
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ tet_infoline("Animation at 25%");
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 50% progress
+ application.SendNotification();
+ tet_infoline("Animation at 50%");
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheck.Reset();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 75% progress
+ tet_infoline("Animation at 75%");
+ application.SendNotification();
+
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 100% progress
+ tet_infoline("Animation at 100%");
+ application.SendNotification();
+
+ //Nothing check at 100% progress. cause It can be both 100% and 0%.
+ finishCheck.CheckSignalNotReceived();
+ application.SendNotification();
+ }
+ finishCheck.CheckSignalNotReceived();
+
+ animation.Stop();
+ animation.SetLooping(false);
+ animation.SetLoopCount(4);
+ animation.Play();
+ application.Render(0u);
+ application.SendNotification();
+
+ for(int count = 0; count < 4; count++)
+ {
+ application.SendNotification();
+ application.Render(0); // start animation
+ progressCheck.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 25% progress
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ tet_infoline("Animation at 25%");
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 50% progress
+ application.SendNotification();
+ tet_infoline("Animation at 50%");
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheck.Reset();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 75% progress
+ tet_infoline("Animation at 75%");
+ application.SendNotification();
+
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 100% progress
+ tet_infoline("Animation at 100%");
+ application.SendNotification();
+
+ //Nothing check at 100% progress. cause It can be both 100% and 0%.
+ application.SendNotification();
+ }
+ application.Render(10u);
+ application.SendNotification();
+ application.Render(0u);
+ application.SendNotification();
+
+ finishCheck.CheckSignalReceived();
+
+ END_TEST;
+}
+
+int UtcDaliAnimationProgressCallbackInvalidSignalN(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animation = Animation::New(0.0f);
+
+ //Set duration
+ const float durationSeconds(1.0f);
+ animation.SetDuration(durationSeconds);
+
+ bool finishedSignalReceived(false);
+ bool progressSignalReceived(false);
+
+ AnimationFinishCheck finishCheck(finishedSignalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+
+ AnimationProgressCheck progressCheck(progressSignalReceived);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ tet_infoline("Animation Progress PlayRange as 10% ~ 90%");
+ animation.SetPlayRange(Vector2(0.1f, 0.9f));
+
+ tet_infoline("Animation Progress notification set to >90% that never can notificated");
+ DevelAnimation::SetProgressNotification(animation, 0.9f + Math::MACHINE_EPSILON_1);
+
+ application.SendNotification();
+ application.Render();
+
+ progressCheck.CheckSignalNotReceived();
+
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 35% progress
+ DALI_TEST_EQUALS(0.35f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ tet_infoline("Animation at 35%");
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 60% progress
+ application.SendNotification();
+ DALI_TEST_EQUALS(0.6f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ tet_infoline("Animation at 60%");
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 85% progress
+ tet_infoline("Animation at 85%");
+ application.SendNotification();
+ DALI_TEST_EQUALS(0.85f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 90% progress
+ tet_infoline("Animation over 90%");
+ application.SendNotification();
+
+ // progress never signaled because playrange is 90%
+ progressCheck.CheckSignalNotReceived();
+
+ END_TEST;
+}
+
+int UtcDaliAnimationProgressCallbackLongDurationP(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animation = Animation::New(0.0f);
+
+ //Set duration
+ float durationSeconds(5.0f);
+ animation.SetDuration(durationSeconds);
+
+ bool finishedSignalReceived(false);
+ bool progressSignalReceived(false);
+
+ AnimationFinishCheck finishCheck(finishedSignalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+
+ AnimationProgressCheck progressCheck(progressSignalReceived);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
+ application.SendNotification();
+
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ tet_infoline("Animation Progress notification set to 50%");
+ DevelAnimation::SetProgressNotification(animation, 0.5f);
+
+ application.SendNotification();
+ application.Render();
+
+ progressCheck.CheckSignalNotReceived();
+
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 25% progress
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ tet_infoline("Animation at 25%");
+
+ progressCheck.CheckSignalNotReceived();
+
+ application.SendNotification();
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 50% progress
+ application.SendNotification();
+ tet_infoline("Animation at 50%");
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalReceived();
+
+ tet_infoline("Progress check reset");
+ progressCheck.Reset();
+
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 75% progress
+ tet_infoline("Animation at 75%");
+ application.SendNotification();
+
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
+
+ progressCheck.CheckSignalNotReceived();
+
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateByInvalidParameters(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Create the animation
+ Animation animation = Animation::New(1.0f);
+
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable property (STRING)
+ animation.AnimateBy(Property(actor, Actor::Property::LAYOUT_DIRECTION), Property::Value("new direction"));
+ },
+ "Property type is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable property (MATRIX)
+ Property::Index index = actor.RegisterProperty("Foobar", Property::Value(Dali::Matrix()), Property::ANIMATABLE);
+ animation.AnimateBy(Property(actor, index), Property::Value(Property::MATRIX));
+ },
+ "Property type is not animatable");
+
+ // AnimateBy
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable target (NONE)
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Property::Value());
+ },
+ "Target value is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable target (STRING)
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Property::Value("foo"));
+ },
+ "Target value is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // not mathing properties (VECTOR3, FLOAT)
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Property::Value(10.f));
+ },
+ "Property and target types don't match");
+
+ DALI_TEST_ASSERTION(
+ {
+ // not mathing properties (VECTOR3.A, VECTOR2)
+ animation.AnimateBy(Property(actor, Actor::Property::COLOR_ALPHA), Property::Value(Property::VECTOR2));
+ },
+ "Property and target types don't match");
+
+ DALI_TEST_ASSERTION(
+ {
+ // negative duration
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Property::Value(Vector3(1, 2, 3)), TimePeriod(-1));
+ },
+ "Duration must be >=0");
+
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateToInvalidParameters(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Create the animation
+ Animation animation = Animation::New(1.0f);
+
+ // AnimateTo
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable property (MAP)
+ Property::Index index = actor.RegisterProperty("Foobar", Property::Value(Property::MAP), Property::ANIMATABLE);
+ animation.AnimateTo(Property(actor, index), Property::Value(Property::MAP));
+ },
+ "Property type is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable target (NONE)
+ animation.AnimateTo(Property(actor, Actor::Property::CLIPPING_MODE), Property::Value());
+ },
+ "Property type is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable target (ARRAY)
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Property::Value(Property::ARRAY));
+ },
+ "Target value is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable target (RECTANGLE)
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Property::Value(Rect<int32_t>()));
+ },
+ "Target value is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // not mathing properties (FLOAT, INT)
+ animation.AnimateTo(Property(actor, Actor::Property::SCALE_Y), Property::Value(10));
+ },
+ "Property and target types don't match");
+
+ DALI_TEST_ASSERTION(
+ {
+ // not mathing properties (VECTOR3, VECTOR2)
+ animation.AnimateTo(Property(actor, Actor::Property::COLOR), Property::Value(Property::VECTOR2));
+ },
+ "Property and target types don't match");
+
+ DALI_TEST_ASSERTION(
+ {
+ // negative duration
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Property::Value(Vector3(1, 2, 3)), TimePeriod(-1));
+ },
+ "Duration must be >=0");
+
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenInvalidParameters(void)
+{
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Create the animation
+ Animation animation = Animation::New(1.0f);
+
+ // AnimateBetween
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable property (ARRAY)
+ Property::Index index = actor.RegisterProperty("Foobar", Property::Value(Property::ARRAY), Property::ANIMATABLE);
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value(Property::ARRAY));
+ animation.AnimateBetween(Property(actor, index), keyframes);
+ },
+ "Property type is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable target (NONE)
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value());
+ animation.AnimateBetween(Property(actor, Actor::Property::CLIPPING_MODE), keyframes);
+ },
+ "Property type is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable target (EXTENTS)
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value(Property::EXTENTS)); // throws
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes);
+ },
+ "Property type is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // non animateable target (RECTANGLE)
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value(Property::MAP)); // throws
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes);
+ },
+ "Property type is not animatable");
+
+ DALI_TEST_ASSERTION(
+ {
+ // not mathing properties (VECTOR2, VECTOR4)
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value(Vector4(1, 2, 3, 4)));
+ animation.AnimateBetween(Property(actor, Actor::Property::MAXIMUM_SIZE), keyframes);
+ },
+ "Property and target types don't match");
+
+ DALI_TEST_ASSERTION(
+ {
+ // negative duration
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value(Vector3(1, 2, 3)));
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes, TimePeriod(-1));
+ },
+ "Duration must be >=0");
+
+ END_TEST;
+}
+
+namespace // Purposefully left this in the middle as the values in this namespace are only used for the subsequent two test cases
+{
+enum TestFunction
+{
+ STOP,
+ CLEAR
+};
+
+void CheckPropertyValuesWhenCallingAnimationMethod(TestFunction functionToTest, const char* testName)
+{
+ tet_printf("Testing %s\n", testName);
+
+ // When an Animation::Stop() or Animation::Clear() is called, the event-side property needs to be updated appropriately
+ // This test checks that that is being done
+
+ const float durationSeconds(1.0f);
+ unsigned int halfAnimationDuration(static_cast<unsigned int>(durationSeconds * 1000.0f * 0.5f));
+ const Vector3 originalPosition(Vector3::ZERO);
+ const Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ const Vector3 halfWayToTarget(targetPosition * 0.5f);
+
+ struct ExpectedValue
+ {
+ Animation::EndAction endAction;
+ Vector3 expectedGetPropertyValue;
+ };
+
+ ExpectedValue expectedValueTable[] =
+ {
+ {Animation::BAKE, halfWayToTarget}, // When baking, the current value is the final value.
+ {Animation::BAKE_FINAL, targetPosition}, // When BakeFinal, we should jump to the final value when clearing or stopping.
+ {Animation::DISCARD, originalPosition}, // When discarding, we should jump back to the original value when clearing or stopping.
+ };
+ const auto expectedValueTableCount = sizeof(expectedValueTable) / sizeof(ExpectedValue);
+
+ for(auto i = 0u; i < expectedValueTableCount; ++i)
+ {
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetEndAction(expectedValueTable[i].endAction);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ // Start the animation
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(halfAnimationDuration);
+
+ // Stop or Clear the animation early, both have the same effect
+ if(functionToTest == TestFunction::STOP)
+ {
+ animation.Stop();
+ }
+ else
+ {
+ animation.Clear();
+ }
+
+ // The event side property should be set the expected value immediately, the update side property will still only be halfway as we haven't run an update yet
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION).Get<Vector3>(), expectedValueTable[i].expectedGetPropertyValue, VECTOR3_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION);
+
+ // After one frame, both values should match regardless of the End Action
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION).Get<Vector3>(), expectedValueTable[i].expectedGetPropertyValue, VECTOR3_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), expectedValueTable[i].expectedGetPropertyValue, VECTOR3_EPSILON, TEST_LOCATION);
+ }
+}
+} // unnamed namespace
+
+int UtcDaliAnimationStopPropertyValue(void)
+{
+ CheckPropertyValuesWhenCallingAnimationMethod(TestFunction::STOP, "UtcDaliAnimationStopPropertyValue");
+ END_TEST;
+}
+
+int UtcDaliAnimationClearPropertyValue(void)
+{
+ CheckPropertyValuesWhenCallingAnimationMethod(TestFunction::CLEAR, "UtcDaliAnimationStopPropertyValue");
+ END_TEST;
+}
+
+int UtcDaliAnimationPausePropertyValue(void)
+{
+ const float durationSeconds(1.0f);
+ unsigned int halfAnimationDuration(static_cast<unsigned int>(durationSeconds * 1000.0f * 0.5f));
+ const Vector3 originalPosition(Vector3::ZERO);
+ const Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ const Vector3 halfWayToTarget(targetPosition * 0.5f);
+
+ Animation::EndAction endActions[] =
+ {
+ Animation::BAKE,
+ Animation::BAKE_FINAL,
+ Animation::DISCARD,
+ };
+ const auto endActionCount = sizeof(endActions) / sizeof(endActions[0]);
+
+ // For all end actions, when pausing, we stay at the current value
+ for(auto i = 0u; i < endActionCount; ++i)
+ {
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ // Build the animation
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetEndAction(endActions[i]);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ // Start the animation
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(halfAnimationDuration);
+
+ // Puase the animation early
+ animation.Pause();
+
+ // The event side property should be set the current value immediately, the update side property will still only be halfway
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION).Get<Vector3>(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION);
+
+ // After one frame, both values should match regardless of the End Action
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION).Get<Vector3>(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION);
+ }
+
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayFromWithLoopCount(void)
+{
+ TestApplication application;
+
+ auto actor = Actor::New();
+ application.GetScene().Add(actor);
+
+ auto animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 100.0f);
+ animation.SetLoopCount(2);
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(1001);
+
+ // One loop completed
+
+ application.Render(2005);
+ application.SendNotification();
+
+ // 2 loops should have completed
+ DALI_TEST_EQUALS(animation.GetCurrentLoop(), 2u, TEST_LOCATION);
+
+ // Another render needs to occur after all the loops end
+ application.SendNotification();
+ application.Render(1000);
+
+ // Stop the animation and use PlayFrom, previously we got an Assert here
+ animation.Stop();
+ animation.PlayFrom(0.5f);
+
+ application.SendNotification();
+ application.Render(1000);
+
+ DALI_TEST_EQUALS(animation.GetState(), Animation::PLAYING, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliAnimationCombineToAndByWithStop(void)
+{
+ tet_infoline("Ensure the Y Position is not modified when animating the X position using AnimateTo and AnimateBy");
+
+ TestApplication application;
+
+ auto actor = Actor::New();
+ actor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(actor);
+
+ auto animation = Animation::New(1.0f);
+ const float origY = actor.GetProperty(Actor::Property::POSITION_Y).Get<float>();
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Vector3(150.0f, origY, 0.0f), TimePeriod(1.0f));
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Vector3(-30.0f, 0.0f, 0.0f), TimePeriod(1.0f, 1.0f));
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(500);
+
+ application.SendNotification();
+ application.Render(500);
+
+ application.SendNotification();
+ application.Render(500);
+
+ // Stop and clear the animation using the current values
+ animation.Stop();
+ animation.Clear();
+
+ // Check the y position, it should be the same as before
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION_Y).Get<float>(), origY, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliAnimationCountAndGetAnimationAt(void)
+{
+ tet_infoline("UtcDaliAnimationCountAndGetAnimationAt");
+
+ TestApplication application;
+
+ auto actor = Actor::New();
+ actor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(actor);
+
+ auto animation = Animation::New(1.0f);
+ const float origY = actor.GetProperty(Actor::Property::POSITION_Y).Get<float>();
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Vector3(150.0f, origY, 0.0f), TimePeriod(1.0f));
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(500);
+
+ uint32_t animationCount = Dali::DevelAnimation::GetAnimationCount();
+ DALI_TEST_EQUALS(animationCount, 1, TEST_LOCATION);
+
+ DALI_TEST_CHECK(!Dali::DevelAnimation::GetAnimationAt(5));
+
+ Dali::Animation animationReturned = Dali::DevelAnimation::GetAnimationAt(0);
+ DALI_TEST_EQUALS(animationReturned.GetState(), Dali::Animation::State::PLAYING, TEST_LOCATION);
+
+ DALI_TEST_EQUALS(animation.GetDuration(), animationReturned.GetDuration(), TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.GetLoopCount(), animationReturned.GetLoopCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.IsLooping(), animationReturned.IsLooping(), TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.GetEndAction(), animationReturned.GetEndAction(), TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.GetState(), animationReturned.GetState(), TEST_LOCATION);
+
+ // Stop and clear the animation using the current values
+ animation.Stop();
+ animation.Clear();
+
+ END_TEST;
+}
+
+int UtcDaliAnimationSetLoopingNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ bool arg1(false);
+ instance.SetLooping(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetDurationNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.SetDuration(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetLoopCountNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetLoopCount();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetEndActionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Animation::EndAction arg1(Animation::BAKE);
+ instance.SetEndAction(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetLoopCountNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ int arg1(0);
+ instance.SetLoopCount(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetPlayRangeNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Vector2 arg1;
+ instance.SetPlayRange(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative01(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ instance.AnimateBetween(arg1, arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative02(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::Animation::Interpolation arg3(Animation::LINEAR);
+ instance.AnimateBetween(arg1, arg2, arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative03(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::TimePeriod arg3(1.0f);
+ instance.AnimateBetween(arg1, arg2, arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative04(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::TimePeriod arg3(1.0f);
+ Dali::Animation::Interpolation arg4(Animation::LINEAR);
+ instance.AnimateBetween(arg1, arg2, arg3, arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative05(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::AlphaFunction arg3;
+ instance.AnimateBetween(arg1, arg2, arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative06(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::AlphaFunction arg3;
+ Dali::Animation::Interpolation arg4(Animation::LINEAR);
+ instance.AnimateBetween(arg1, arg2, arg3, arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative07(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
+ instance.AnimateBetween(arg1, arg2, arg3, arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateBetweenNegative08(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
+ Dali::Animation::Interpolation arg5(Animation::LINEAR);
+ instance.AnimateBetween(arg1, arg2, arg3, arg4, arg5);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationFinishedSignalNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.FinishedSignal();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetCurrentLoopNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetCurrentLoop();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetLoopingModeNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Animation::LoopingMode arg1(Animation::RESTART);
+ instance.SetLoopingMode(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetSpeedFactorNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.SetSpeedFactor(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetCurrentProgressNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetCurrentProgress();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetCurrentProgressNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.SetCurrentProgress(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetDisconnectActionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Animation::EndAction arg1(Animation::BAKE);
+ instance.SetDisconnectAction(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationSetDefaultAlphaFunctionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::AlphaFunction arg1;
+ instance.SetDefaultAlphaFunction(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationHideNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ float arg2(0.0f);
+ instance.Hide(arg1, arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.Play();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationShowNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ float arg2(0.0f);
+ instance.Show(arg1, arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationStopNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.Stop();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationClearNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.Clear();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationPauseNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.Pause();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateNegative01(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
+ instance.Animate(arg1, arg2, arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateNegative02(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
+ Dali::TimePeriod arg4(1.0f);
+ instance.Animate(arg1, arg2, arg3, arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateNegative03(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
+ Dali::AlphaFunction arg4;
+ instance.Animate(arg1, arg2, arg3, arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateNegative04(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
+ Dali::AlphaFunction arg4;
+ Dali::TimePeriod arg5(1.0f);
+ instance.Animate(arg1, arg2, arg3, arg4, arg5);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayFromNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.PlayFrom(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateByNegative01(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ instance.AnimateBy(arg1, arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateByNegative02(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::TimePeriod arg3(1.0f);
+ instance.AnimateBy(arg1, arg2, arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateByNegative03(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::AlphaFunction arg3;
+ instance.AnimateBy(arg1, arg2, arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateByNegative04(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
+ instance.AnimateBy(arg1, arg2, arg3, arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateToNegative01(void)
+{
+ TestApplication application;
+ Dali::Actor actor;
+ Dali::Animation instance;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ instance.AnimateTo(arg1, arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateToNegative02(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::TimePeriod arg3(1.0f);
+ instance.AnimateTo(arg1, arg2, arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateToNegative03(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::AlphaFunction arg3;
+ instance.AnimateTo(arg1, arg2, arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationAnimateToNegative04(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ Dali::Actor actor;
+ try
+ {
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property::Value arg2;
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
+ instance.AnimateTo(arg1, arg2, arg3, arg4);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayAfterNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ float arg1(0.0f);
+ instance.PlayAfter(arg1);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetDurationNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetDuration();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetEndActionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetEndAction();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetPlayRangeNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetPlayRange();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetLoopingModeNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetLoopingMode();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetSpeedFactorNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetSpeedFactor();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetDisconnectActionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetDisconnectAction();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetDefaultAlphaFunctionNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetDefaultAlphaFunction();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationGetStateNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.GetState();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliAnimationIsLoopingNegative(void)
+{
+ TestApplication application;
+ Dali::Animation instance;
+ try
+ {
+ instance.IsLooping();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliKeyFramesAddNegative01(void)
+{
+ TestApplication application;
+ Dali::KeyFrames instance;
+ try
+ {
+ float arg1(0.0f);
+ Dali::Property::Value arg2;
+ instance.Add(arg1, arg2);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliKeyFramesAddNegative02(void)
+{
+ TestApplication application;
+ Dali::KeyFrames instance;
+ try
+ {
+ float arg1(0.0f);
+ Dali::Property::Value arg2;
+ Dali::AlphaFunction arg3;
+ instance.Add(arg1, arg2, arg3);
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }
+ END_TEST;
+}
+
+int UtcDaliKeyFramesGetTypeNegative(void)
+{
+ TestApplication application;
+ Dali::KeyFrames instance;
+ try
+ {
+ instance.GetType();
+ DALI_TEST_CHECK(false); // Should not get here
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true); // We expect an assert
+ }