END_TEST;
}
-int UtcDaliAnimationSetDuratioN(void)
+int UtcDaliAnimationSetDurationP(void)
{
TestApplication application;
// Start the animation
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
animation.Play();
bool signalReceived(false);
END_TEST;
}
-int UtcDaliAnimationGetDuratioN(void)
+int UtcDaliAnimationGetDurationP(void)
{
TestApplication application;
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.SetLooping(true);
DALI_TEST_CHECK(animation.GetEndAction() == Animation::Bake);
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
END_TEST;
}
-int UtcDaliAnimationGetEndActioN(void)
+int UtcDaliAnimationGetEndActionP(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliAnimationSetDisconnectActioN(void)
+int UtcDaliAnimationSetDisconnectActionP(void)
{
TestApplication application;
Stage stage( Stage::GetCurrent() );
DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::BakeFinal);
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
animation.SetDisconnectAction( Animation::Bake );
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
animation.SetDisconnectAction( Animation::Discard );
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
END_TEST;
}
-int UtcDaliAnimationGetDisconnectActioN(void)
+int UtcDaliAnimationGetDisconnectActionP(void)
{
TestApplication application;
Animation animation = Animation::New(1.0f);
END_TEST;
}
-int UtcDaliAnimationSetDefaultAlphaFunctioN(void)
+int UtcDaliAnimationSetDefaultAlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(1.0f);
AlphaFunction func = animation.GetDefaultAlphaFunction();
- DALI_TEST_EQUALS(func(0.1f), AlphaFunctions::Linear(0.1f), TEST_LOCATION);
+ DALI_TEST_EQUALS(func.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
- animation.SetDefaultAlphaFunction(AlphaFunctions::EaseIn);
+ animation.SetDefaultAlphaFunction(AlphaFunction::EASE_IN);
AlphaFunction func2 = animation.GetDefaultAlphaFunction();
- DALI_TEST_CHECK(func2(0.1f) < AlphaFunctions::Linear(0.1f)); // less progress when easing-in
+ DALI_TEST_EQUALS(func2.GetBuiltinFunction(), AlphaFunction::EASE_IN, TEST_LOCATION);
END_TEST;
}
-int UtcDaliAnimationGetDefaultAlphaFunctioN(void)
+int UtcDaliAnimationGetDefaultAlphaFunctionP(void)
{
TestApplication application;
AlphaFunction func = animation.GetDefaultAlphaFunction();
// Test that the default is linear
- DALI_TEST_EQUALS(func(0.1f), AlphaFunctions::Linear(0.1f), TEST_LOCATION);
+ DALI_TEST_EQUALS(func.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
- animation.SetDefaultAlphaFunction(AlphaFunctions::EaseIn);
+ animation.SetDefaultAlphaFunction(AlphaFunction::EASE_IN);
AlphaFunction func2 = animation.GetDefaultAlphaFunction();
- DALI_TEST_CHECK(func2(0.1f) < AlphaFunctions::Linear(0.1f)); // less progress when easing-in
+ DALI_TEST_EQUALS(func2.GetBuiltinFunction(), AlphaFunction::EASE_IN, TEST_LOCATION);
END_TEST;
}
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation from 40% progress
animation.SetCurrentProgress( 0.4f );
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
//Trying to set the current cursor outside the range [0..1] is ignored
animation.SetCurrentProgress( -1.0f);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation from 40% progress
animation.SetCurrentProgress( 0.4f );
KeyFrames keyframes = KeyFrames::New();
keyframes.Add( 0.0f, initialPosition);
keyframes.Add( 1.0f, targetPosition );
- animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunctions::Linear);
+ animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
//Set speed to be x2
animation.SetSpeedFactor(2.0f);
DALI_TEST_EQUALS( Vector2( 0.4f, 0.9f ), animation.GetPlayRange(), TEST_LOCATION );
Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunctions::Linear );
+ animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR );
// Start the animation from 40% progress
animation.Play();
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
Animation animation = Animation::New(durationSeconds);
animation.SetDisconnectAction( Animation::Discard );
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation from 40% progress
animation.PlayFrom( 0.4f );
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
//PlayFrom with an argument outside the range [0..1] will be ignored
animation.PlayFrom(-1.0f);
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
Vector3 fiftyPercentProgress(targetPosition * 0.5f);
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
Vector3 fiftyPercentProgress(targetPosition * 0.5f);
END_TEST;
}
-int UtcDaliAnimationStopSetPositioN(void)
+int UtcDaliAnimationStopSetPositionP(void)
{
// Test that Animation::Stop & Actor::SetPosition can be used in conjunction
// i.e. to check that the animation does not interfere with the position set.
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
Vector3 fiftyPercentProgress(targetPosition * 0.5f);
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::Linear);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
Vector3 fiftyPercentProgress(targetPosition * 0.5f);
finishCheck.Reset();
actor.SetPosition(Vector3::ZERO);
Vector3 targetScale(3.0f, 3.0f, 3.0f);
- animation.AnimateTo( Property( actor, Actor::Property::SCALE ), targetScale, AlphaFunctions::Linear );
+ animation.AnimateTo( Property( actor, Actor::Property::SCALE ), targetScale, AlphaFunction::LINEAR );
animation.Play();
application.SendNotification();
END_TEST;
}
-int UtcDaliAnimationAnimateByBooleaN(void)
+int UtcDaliAnimationAnimateByBooleanP(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliAnimationAnimateByBooleanAlphaFunctioN(void)
+int UtcDaliAnimationAnimateByBooleanAlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
bool relativeValue(true);
bool finalValue( false || relativeValue );
- animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseIn);
+ animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_IN);
// Start the animation
animation.Play();
// Repeat with relative value "false" - this should be an NOOP
animation = Animation::New(durationSeconds);
bool noOpValue(false);
- animation.AnimateBy(Property(actor, index), noOpValue, AlphaFunctions::EaseIn);
+ animation.AnimateBy(Property(actor, index), noOpValue, AlphaFunction::EASE_IN);
// Start the animation
animation.Play();
float animatorDurationSeconds(durationSeconds * 0.5f);
animation.AnimateBy( Property(actor, index),
relativeValue,
- AlphaFunctions::EaseInOut,
+ AlphaFunction::EASE_IN_OUT,
TimePeriod( animatorDurationSeconds ) );
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateByFloatAlphaFunctioN(void)
+int UtcDaliAnimationAnimateByFloatAlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
float targetValue(90.0f);
float relativeValue(targetValue - startValue);
- animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseOut);
+ animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateByIntegerAlphaFunctioN(void)
+int UtcDaliAnimationAnimateByIntegerAlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
int targetValue(90);
int relativeValue(targetValue - startValue);
- animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseOut);
+ animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateByVector2AlphaFunctioN(void)
+int UtcDaliAnimationAnimateByVector2AlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
Vector2 targetValue(20.0f, 20.0f);
Vector2 relativeValue(targetValue - startValue);
- animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseOut);
+ animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateByVector3AlphaFunctioN(void)
+int UtcDaliAnimationAnimateByVector3AlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
Vector3 targetValue(20.0f, 20.0f, 20.0f);
Vector3 relativeValue(targetValue - startValue);
- animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseOut);
+ animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateByVector4AlphaFunctioN(void)
+int UtcDaliAnimationAnimateByVector4AlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
Vector4 targetValue(20.0f, 20.0f, 20.0f, 20.0f);
Vector4 relativeValue(targetValue - startValue);
- animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunctions::EaseOut);
+ animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateByActorPositioN(void)
+int UtcDaliAnimationAnimateByActorPositionP(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliAnimationAnimateByActorPositionAlphaFunctioN(void)
+int UtcDaliAnimationAnimateByActorPositionAlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(20.0f, 20.0f, 20.0f);
Vector3 relativePosition(targetPosition - startPosition);
- animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition, AlphaFunctions::EaseOut);
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition, AlphaFunction::EASE_OUT);
Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
float delay = 0.5f;
animation.AnimateBy(Property(actor, Actor::Property::POSITION),
relativePosition,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
END_TEST;
}
-int UtcDaliAnimationAnimateByActorOrientatioN(void)
+int UtcDaliAnimationAnimateByActorOrientationP(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliAnimationAnimateByActorOrientationAlphaFunctioN(void)
+int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
Degree relativeRotationDegrees(360.0f);
Radian relativeRotationRadians(relativeRotationDegrees);
- animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ), AlphaFunctions::EaseIn );
+ animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ), AlphaFunction::EASE_IN );
// Start the animation
animation.Play();
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(0.25f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.25f*0.25f*0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(0.5f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.5f*0.5f*0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(0.75f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * 0.75f*0.75f*0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
Radian relativeRotationRadians(relativeRotationDegrees);
float delay = 0.3f;
animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ),
- AlphaFunctions::EaseIn, TimePeriod( delay, durationSeconds - delay ) );
+ AlphaFunction::EASE_IN, TimePeriod( delay, durationSeconds - delay ) );
// Start the animation
animation.Play();
application.SendNotification();
finishCheck.CheckSignalNotReceived();
float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
// Repeat with a different (ease-in) alpha function
animation = Animation::New(durationSeconds);
- animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunctions::EaseIn );
+ animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunction::EASE_IN );
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
// Repeat with a delay
float delay = 0.5f;
animation = Animation::New(durationSeconds);
- animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunctions::Linear, TimePeriod( delay, durationSeconds - delay ) );
+ animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
END_TEST;
}
-int UtcDaliAnimationAnimateToBooleaN(void)
+int UtcDaliAnimationAnimateToBooleanP(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliAnimationAnimateToBooleanAlphaFunctioN(void)
+int UtcDaliAnimationAnimateToBooleanAlphaFunctionP(void)
{
TestApplication application;
float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
const bool targetValue( !startValue );
- animation.AnimateTo(Property(actor, "test-property"), targetValue, AlphaFunctions::EaseOut);
+ animation.AnimateTo(Property(actor, "test-property"), targetValue, AlphaFunction::EASE_OUT);
// Start the animation
animation.Play();
// Repeat with target value "false"
animation = Animation::New(durationSeconds);
const bool finalValue( !targetValue );
- animation.AnimateTo(Property(actor, index), finalValue, AlphaFunctions::EaseOut);
+ animation.AnimateTo(Property(actor, index), finalValue, AlphaFunction::EASE_OUT);
// Start the animation
animation.Play();
float animatorDurationSeconds(durationSeconds * 0.5f);
animation.AnimateTo( Property(actor, index),
finalValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod( animatorDurationSeconds ) );
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateToFloatAlphaFunctioN(void)
+int UtcDaliAnimationAnimateToFloatAlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
float targetValue(90.0f);
float relativeValue(targetValue - startValue);
- animation.AnimateTo(Property(actor, index), targetValue, AlphaFunctions::EaseOut);
+ animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateToIntegerAlphaFunctioN(void)
+int UtcDaliAnimationAnimateToIntegerAlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
int targetValue(90);
int relativeValue(targetValue - startValue);
- animation.AnimateTo(Property(actor, index), targetValue, AlphaFunctions::EaseOut);
+ animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateToVector2AlphaFunctioN(void)
+int UtcDaliAnimationAnimateToVector2AlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
Vector2 targetValue(9000.0f, 9000.0f);
Vector2 relativeValue(targetValue - startValue);
- animation.AnimateTo(Property(actor, "test-property"), targetValue, AlphaFunctions::EaseOut);
+ animation.AnimateTo(Property(actor, "test-property"), targetValue, AlphaFunction::EASE_OUT);
Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateToVector3AlphaFunctioN(void)
+int UtcDaliAnimationAnimateToVector3AlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
Vector3 targetValue(9000.0f, 9000.0f, 9000.0f);
Vector3 relativeValue(targetValue - startValue);
- animation.AnimateTo(Property(actor, index), targetValue, AlphaFunctions::EaseOut);
+ animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
float delay = 0.5f;
animation.AnimateTo(Property(actor, "test-property"),
targetValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
float delay = 0.5f;
animation.AnimateTo(Property(actor, "test-property", 0),
30.0f,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
animation.AnimateTo(Property(actor, index, 1),
30.0f,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateToVector4AlphaFunctioN(void)
+int UtcDaliAnimationAnimateToVector4AlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
Vector4 targetValue(9000.0f, 9000.0f, 9000.0f, 9000.0f);
Vector4 relativeValue(targetValue - startValue);
- animation.AnimateTo(Property(actor, index), targetValue, AlphaFunctions::EaseOut);
+ animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
END_TEST;
}
-int UtcDaliAnimationAnimateToActorParentOrigiN(void)
+int UtcDaliAnimationAnimateToActorParentOriginP(void)
{
TestApplication application;
// Repeat with a different (ease-in) alpha function
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunctions::EaseIn);
+ animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::EASE_IN);
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
// Repeat with a delay
float delay = 0.5f;
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunctions::Linear, TimePeriod(delay, durationSeconds - delay));
+ animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
// Repeat with a different (ease-in) alpha function
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunctions::EaseIn );
- animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunctions::EaseIn );
+ animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunction::EASE_IN );
+ animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunction::EASE_IN );
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
// Repeat with a delay
float delay = 0.5f;
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunctions::Linear, TimePeriod( delay, durationSeconds - delay ) );
- animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunctions::Linear, TimePeriod( delay, durationSeconds - delay ) );
+ animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
+ animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
END_TEST;
}
-int UtcDaliAnimationAnimateToActorPositioN(void)
+int UtcDaliAnimationAnimateToActorPositionP(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliAnimationAnimateToActorPositionAlphaFunctioN(void)
+int UtcDaliAnimationAnimateToActorPositionAlphaFunctionP(void)
{
TestApplication application;
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(200.0f, 200.0f, 200.0f);
- animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunctions::EaseIn);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::EASE_IN);
Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
float delay = 0.5f;
animation.AnimateTo( Property(actor, Actor::Property::POSITION),
targetPosition,
- AlphaFunctions::Linear,
+ AlphaFunction::LINEAR,
TimePeriod( delay, durationSeconds - delay ) );
Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
END_TEST;
}
-int UtcDaliAnimationAnimateToActorOrientationQuaternioN(void)
+int UtcDaliAnimationAnimateToActorOrientationQuaternionP(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliAnimationAnimateToActorOrientationAlphaFunctioN(void)
+int UtcDaliAnimationAnimateToActorOrientationAlphaFunctionP(void)
{
TestApplication application;
Animation animation = Animation::New(durationSeconds);
Degree targetRotationDegrees(90.0f);
Radian targetRotationRadians(targetRotationDegrees);
- animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunctions::EaseIn);
+ animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN);
// Start the animation
animation.Play();
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(0.25f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.25f*0.25f*0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(0.5f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.5f*0.5f*0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(0.75f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * 0.75f*0.75f*0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
Degree targetRotationDegrees(90.0f);
Radian targetRotationRadians(targetRotationDegrees);
float delay(0.1f);
- animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunctions::EaseIn, TimePeriod(delay, durationSeconds - delay));
+ animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN, TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
application.SendNotification();
finishCheck.CheckSignalNotReceived();
float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * AlphaFunctions::EaseIn(progress), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS( actor.GetCurrentOrientation(), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
// Repeat with a different (ease-in) alpha function
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunctions::EaseIn);
+ animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::EASE_IN);
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
// Repeat with a delay
float delay = 0.5f;
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunctions::Linear, TimePeriod(delay, durationSeconds - delay));
+ animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
// Repeat with a different (ease-in) alpha function
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunctions::EaseIn);
+ animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::EASE_IN);
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
// Repeat with a shorter animator duration
float animatorDuration = 0.5f;
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunctions::Linear, TimePeriod(animatorDuration));
+ animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::LINEAR, TimePeriod(animatorDuration));
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
END_TEST;
}
-int UtcDaliAnimationAnimateToActorColorGreeN(void)
+int UtcDaliAnimationAnimateToActorColorGreenP(void)
{
TestApplication application;
END_TEST;
}
-int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctioN(void)
+int UtcDaliAnimationAnimateBetweenActorColorAlphaFunctionP(void)
{
TestApplication application;
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunctions::Linear );
+ animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR );
// Start the animation
animation.Play();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunctions::Linear, Animation::Cubic );
+ animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, Animation::Cubic );
// Start the animation
animation.Play();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunctions::Linear, TimePeriod( delay, durationSeconds - delay ) );
+ animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
// Start the animation
animation.Play();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunctions::Linear, TimePeriod( delay, durationSeconds - delay ), Animation::Cubic );
+ animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ), Animation::Cubic );
// Start the animation
animation.Play();
END_TEST;
}
-int UtcDaliAnimationAnimateAlphaFunctioN(void)
+int UtcDaliAnimationAnimateAlphaFunctionP(void)
{
TestApplication application;
// Build the animation
float durationSeconds( 1.0f );
Animation animation = Animation::New(durationSeconds);
- animation.Animate(actor, path, Vector3::XAXIS, AlphaFunctions::Linear);
+ animation.Animate(actor, path, Vector3::XAXIS, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
// Build the animation
float durationSeconds( 1.0f );
Animation animation = Animation::New(durationSeconds);
- animation.Animate(actor, path, Vector3::XAXIS, AlphaFunctions::Linear, TimePeriod(0.0f, 1.0f));
+ animation.Animate(actor, path, Vector3::XAXIS, AlphaFunction::LINEAR, TimePeriod(0.0f, 1.0f));
// Start the animation
animation.Play();
constraint.Apply();
// Apply animation to actor
- animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 100.f, 90.f, 80.f ), AlphaFunctions::Linear );
+ animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 100.f, 90.f, 80.f ), AlphaFunction::LINEAR );
animation.Play();
animation2.FinishedSignal().Connect( &application, AnimationFinishCheck( signal2Received ) );
// Apply animations to actor
- animation1.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 3.0f, 2.0f, 1.0f ), AlphaFunctions::Linear );
+ animation1.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 3.0f, 2.0f, 1.0f ), AlphaFunction::LINEAR );
animation1.Play();
- animation2.AnimateTo( Property(actor, Actor::Property::SIZE ), Vector3( 10.0f, 20.0f, 30.0f ), AlphaFunctions::Linear );
+ animation2.AnimateTo( Property(actor, Actor::Property::SIZE ), Vector3( 10.0f, 20.0f, 30.0f ), AlphaFunction::LINEAR );
animation2.Play();
DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
END_TEST;
}
-int UtcDaliAnimationExtendDuratioN(void)
+int UtcDaliAnimationExtendDurationP(void)
{
TestApplication application;