CCLayerAnimationControllerTest.cpp [plain text]
#include "config.h"
#include "cc/CCLayerAnimationController.h"
#include "CCAnimationTestCommon.h"
#include "GraphicsLayer.h"
#include "Length.h"
#include "TranslateTransformOperation.h"
#include "cc/CCActiveAnimation.h"
#include "cc/CCAnimationCurve.h"
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <wtf/Vector.h>
using namespace WebCore;
using namespace WebKitTests;
namespace {
void expectTranslateX(double translateX, const TransformationMatrix& matrix)
{
TransformationMatrix::DecomposedType decomposedType;
matrix.decompose(decomposedType);
EXPECT_FLOAT_EQ(translateX, decomposedType.translateX);
}
PassOwnPtr<CCActiveAnimation> createActiveAnimation(PassOwnPtr<CCAnimationCurve> curve, int id, CCActiveAnimation::TargetProperty property)
{
return CCActiveAnimation::create(curve, 0, id, property);
}
TEST(CCLayerAnimationControllerTest, createOpacityAnimation)
{
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
const double duration = 1;
WebCore::KeyframeValueList values(AnimatedPropertyOpacity);
values.insert(new FloatAnimationValue(0, 0));
values.insert(new FloatAnimationValue(duration, 1));
RefPtr<Animation> animation = Animation::create();
animation->setDuration(duration);
IntSize boxSize;
controller->addAnimation(values, boxSize, animation.get(), 0, 0, 0);
EXPECT_TRUE(controller->hasActiveAnimation());
CCActiveAnimation* activeAnimation = controller->getActiveAnimation(0, CCActiveAnimation::Opacity);
EXPECT_TRUE(activeAnimation);
EXPECT_EQ(1, activeAnimation->iterations());
EXPECT_EQ(CCActiveAnimation::Opacity, activeAnimation->targetProperty());
EXPECT_EQ(CCAnimationCurve::Float, activeAnimation->curve()->type());
const CCFloatAnimationCurve* curve = activeAnimation->curve()->toFloatAnimationCurve();
EXPECT_TRUE(curve);
EXPECT_EQ(0, curve->getValue(0));
EXPECT_EQ(1, curve->getValue(duration));
}
TEST(CCLayerAnimationControllerTest, ignoreUnsupportedAnimationDirections)
{
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
const double duration = 1;
WebCore::KeyframeValueList values(AnimatedPropertyOpacity);
values.insert(new FloatAnimationValue(0, 0));
values.insert(new FloatAnimationValue(duration, 1));
RefPtr<Animation> animation = Animation::create();
animation->setDuration(duration);
IntSize boxSize;
animation->setDirection(Animation::AnimationDirectionAlternate);
EXPECT_FALSE(controller->addAnimation(values, boxSize, animation.get(), 0, 0, 0));
animation->setDirection(Animation::AnimationDirectionAlternateReverse);
EXPECT_FALSE(controller->addAnimation(values, boxSize, animation.get(), 0, 0, 0));
animation->setDirection(Animation::AnimationDirectionReverse);
EXPECT_FALSE(controller->addAnimation(values, boxSize, animation.get(), 0, 0, 0));
animation->setDirection(Animation::AnimationDirectionNormal);
EXPECT_TRUE(controller->addAnimation(values, boxSize, animation.get(), 0, 0, 0));
}
TEST(CCLayerAnimationControllerTest, createTransformAnimation)
{
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
const double duration = 1;
WebCore::KeyframeValueList values(AnimatedPropertyWebkitTransform);
TransformOperations operations1;
operations1.operations().append(TranslateTransformOperation::create(Length(2, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X));
values.insert(new TransformAnimationValue(0, &operations1));
TransformOperations operations2;
operations2.operations().append(TranslateTransformOperation::create(Length(4, Fixed), Length(0, Fixed), TransformOperation::TRANSLATE_X));
values.insert(new TransformAnimationValue(duration, &operations2));
RefPtr<Animation> animation = Animation::create();
animation->setDuration(duration);
IntSize boxSize;
controller->addAnimation(values, boxSize, animation.get(), 0, 0, 0);
EXPECT_TRUE(controller->hasActiveAnimation());
CCActiveAnimation* activeAnimation = controller->getActiveAnimation(0, CCActiveAnimation::Transform);
EXPECT_TRUE(activeAnimation);
EXPECT_EQ(1, activeAnimation->iterations());
EXPECT_EQ(CCActiveAnimation::Transform, activeAnimation->targetProperty());
EXPECT_EQ(CCAnimationCurve::Transform, activeAnimation->curve()->type());
const CCTransformAnimationCurve* curve = activeAnimation->curve()->toTransformAnimationCurve();
EXPECT_TRUE(curve);
expectTranslateX(2, curve->getValue(0, boxSize));
expectTranslateX(4, curve->getValue(duration, boxSize));
}
TEST(CCLayerAnimationControllerTest, syncNewAnimation)
{
FakeLayerAnimationControllerClient dummyImpl;
OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController::create(&dummyImpl));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
addOpacityTransitionToController(*controller, 1, 0, 1, false);
controller->pushAnimationUpdatesTo(controllerImpl.get());
EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
}
TEST(CCLayerAnimationControllerTest, doNotClobberStartTimes)
{
FakeLayerAnimationControllerClient dummyImpl;
OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController::create(&dummyImpl));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
addOpacityTransitionToController(*controller, 1, 0, 1, false);
controller->pushAnimationUpdatesTo(controllerImpl.get());
EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
CCAnimationEventsVector events;
controllerImpl->animate(1, &events);
EXPECT_EQ(1u, events.size());
controller->notifyAnimationStarted(events[0]);
EXPECT_EQ(controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->startTime(), controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->startTime());
controller->animate(1.5, 0);
EXPECT_EQ(controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->startTime(), controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->startTime());
}
TEST(CCLayerAnimationControllerTest, syncPauseAndResume)
{
FakeLayerAnimationControllerClient dummyImpl;
OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController::create(&dummyImpl));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
addOpacityTransitionToController(*controller, 1, 0, 1, false);
controller->pushAnimationUpdatesTo(controllerImpl.get());
EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
CCAnimationEventsVector events;
controllerImpl->animate(0, &events);
controller->animate(0, 0);
EXPECT_EQ(CCActiveAnimation::Running, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
EXPECT_EQ(CCActiveAnimation::Running, controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
controller->suspendAnimations(1);
EXPECT_EQ(CCActiveAnimation::Paused, controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
controller->pushAnimationUpdatesTo(controllerImpl.get());
EXPECT_EQ(CCActiveAnimation::Paused, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
controller->resumeAnimations(2);
EXPECT_EQ(CCActiveAnimation::Running, controller->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
controller->pushAnimationUpdatesTo(controllerImpl.get());
EXPECT_EQ(CCActiveAnimation::Running, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
}
TEST(CCLayerAnimationControllerTest, doNotSyncFinishedAnimation)
{
FakeLayerAnimationControllerClient dummyImpl;
OwnPtr<CCLayerAnimationController> controllerImpl(CCLayerAnimationController::create(&dummyImpl));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(CCLayerAnimationController::create(&dummy));
EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
addOpacityTransitionToController(*controller, 1, 0, 1, false);
controller->pushAnimationUpdatesTo(controllerImpl.get());
EXPECT_TRUE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
EXPECT_EQ(CCActiveAnimation::WaitingForTargetAvailability, controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity)->runState());
CCAnimationEvent animationStartedEvent(CCAnimationEvent::Started, 0, 0, CCActiveAnimation::Opacity, 0);
controller->notifyAnimationStarted(animationStartedEvent);
controllerImpl->removeAnimation(0);
EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
controller->pushAnimationUpdatesTo(controllerImpl.get());
EXPECT_FALSE(controllerImpl->getActiveAnimation(0, CCActiveAnimation::Opacity));
}
TEST(CCLayerAnimationControllerTest, TrivialTransition)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
controller->add(toAdd.release());
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(1, events.get());
EXPECT_EQ(1, dummy.opacity());
EXPECT_FALSE(controller->hasActiveAnimation());
}
TEST(CCLayerAnimationControllerTest, AnimationsWaitingForStartTimeDoNotFinishIfTheyWaitLongerToStartThanTheirDuration)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
toAdd->setNeedsSynchronizedStartTime(true);
controller->add(toAdd.release());
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(1, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(2, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->notifyAnimationStarted(CCAnimationEvent(CCAnimationEvent::Started, 0, 1, CCActiveAnimation::Opacity, 2));
controller->animate(5, events.get());
EXPECT_EQ(1, dummy.opacity());
EXPECT_FALSE(controller->hasActiveAnimation());
}
TEST(CCLayerAnimationControllerTest, TrivialQueuing)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.5)), 2, CCActiveAnimation::Opacity));
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(1, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(1, dummy.opacity());
controller->animate(2, events.get());
EXPECT_EQ(0.5, dummy.opacity());
EXPECT_FALSE(controller->hasActiveAnimation());
}
TEST(CCLayerAnimationControllerTest, Interrupt)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.5)), 2, CCActiveAnimation::Opacity));
toAdd->setRunState(CCActiveAnimation::WaitingForNextTick, 0);
controller->add(toAdd.release());
controller->animate(0.5, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(1, dummy.opacity());
controller->animate(1.5, events.get());
EXPECT_EQ(0.5, dummy.opacity());
EXPECT_FALSE(controller->hasActiveAnimation());
}
TEST(CCLayerAnimationControllerTest, ScheduleTogetherWhenAPropertyIsBlocked)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
controller->add(createActiveAnimation(adoptPtr(new FakeTransformTransition(1)), 1, CCActiveAnimation::Transform));
controller->add(createActiveAnimation(adoptPtr(new FakeTransformTransition(1)), 2, CCActiveAnimation::Transform));
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 2, CCActiveAnimation::Opacity));
controller->animate(0, events.get());
EXPECT_EQ(0, dummy.opacity());
EXPECT_TRUE(controller->hasActiveAnimation());
controller->animate(1, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(2, events.get());
EXPECT_EQ(1, dummy.opacity());
EXPECT_FALSE(controller->hasActiveAnimation());
}
TEST(CCLayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
controller->add(createActiveAnimation(adoptPtr(new FakeTransformTransition(2)), 1, CCActiveAnimation::Transform));
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.5)), 2, CCActiveAnimation::Opacity));
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(2, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(1, dummy.opacity());
controller->animate(3, events.get());
EXPECT_EQ(0.5, dummy.opacity());
EXPECT_FALSE(controller->hasActiveAnimation());
}
TEST(CCLayerAnimationControllerTest, ScheduleAnimation)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0);
toAdd->setStartTime(1);
controller->add(toAdd.release());
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(1, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(2, events.get());
EXPECT_EQ(1, dummy.opacity());
EXPECT_FALSE(controller->hasActiveAnimation());
}
TEST(CCLayerAnimationControllerTest, ScheduledAnimationInterruptsRunningAnimation)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), 1, CCActiveAnimation::Opacity));
OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0.5, 0)), 2, CCActiveAnimation::Opacity));
toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0);
toAdd->setStartTime(1);
controller->add(toAdd.release());
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(0.5, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.25, dummy.opacity());
controller->animate(1, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.5, dummy.opacity());
controller->animate(2, events.get());
EXPECT_EQ(0, dummy.opacity());
EXPECT_FALSE(controller->hasActiveAnimation());
}
TEST(CCLayerAnimationControllerTest, ScheduledAnimationInterruptsRunningAnimationWithAnimInQueue)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), 1, CCActiveAnimation::Opacity));
OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0.5, 0)), 2, CCActiveAnimation::Opacity));
toAdd->setRunState(CCActiveAnimation::WaitingForStartTime, 0);
toAdd->setStartTime(1);
controller->add(toAdd.release());
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 0.75)), 3, CCActiveAnimation::Opacity));
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(0.5, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.25, dummy.opacity());
EXPECT_TRUE(controller->hasActiveAnimation());
controller->animate(1, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.5, dummy.opacity());
controller->animate(3, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(4, events.get());
EXPECT_EQ(0.75, dummy.opacity());
EXPECT_FALSE(controller->hasActiveAnimation());
}
TEST(CCLayerAnimationControllerTest, TrivialLooping)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), 1, CCActiveAnimation::Opacity));
toAdd->setIterations(3);
controller->add(toAdd.release());
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(1.25, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.25, dummy.opacity());
controller->animate(1.75, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.75, dummy.opacity());
controller->animate(2.25, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.25, dummy.opacity());
controller->animate(2.75, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.75, dummy.opacity());
controller->animate(3, events.get());
EXPECT_FALSE(controller->hasActiveAnimation());
EXPECT_EQ(1, dummy.opacity());
controller->animate(4, events.get());
EXPECT_EQ(1, dummy.opacity());
}
TEST(CCLayerAnimationControllerTest, InfiniteLooping)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
const int id = 1;
OwnPtr<CCActiveAnimation> toAdd(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), id, CCActiveAnimation::Opacity));
toAdd->setIterations(-1);
controller->add(toAdd.release());
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(1.25, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.25, dummy.opacity());
controller->animate(1.75, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.75, dummy.opacity());
controller->animate(1073741824.25, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.25, dummy.opacity());
controller->animate(1073741824.75, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.75, dummy.opacity());
EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity));
controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Aborted, 0.75);
EXPECT_FALSE(controller->hasActiveAnimation());
EXPECT_EQ(0.75, dummy.opacity());
}
TEST(CCLayerAnimationControllerTest, PauseResume)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
const int id = 1;
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 0, 1)), id, CCActiveAnimation::Opacity));
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(0.5, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.5, dummy.opacity());
EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity));
controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Paused, 0.5);
controller->animate(1024, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.5, dummy.opacity());
EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity));
controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Running, 1024);
controller->animate(1024.25, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.75, dummy.opacity());
controller->animate(1024.5, events.get());
EXPECT_FALSE(controller->hasActiveAnimation());
EXPECT_EQ(1, dummy.opacity());
}
TEST(CCLayerAnimationControllerTest, AbortAGroupedAnimation)
{
OwnPtr<CCAnimationEventsVector> events(adoptPtr(new CCAnimationEventsVector));
FakeLayerAnimationControllerClient dummy;
OwnPtr<CCLayerAnimationController> controller(
CCLayerAnimationController::create(&dummy));
const int id = 1;
controller->add(createActiveAnimation(adoptPtr(new FakeTransformTransition(1)), id, CCActiveAnimation::Transform));
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(2, 0, 1)), id, CCActiveAnimation::Opacity));
controller->add(createActiveAnimation(adoptPtr(new FakeFloatTransition(1, 1, 0.75)), 2, CCActiveAnimation::Opacity));
controller->animate(0, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0, dummy.opacity());
controller->animate(1, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(0.5, dummy.opacity());
EXPECT_TRUE(controller->getActiveAnimation(id, CCActiveAnimation::Opacity));
controller->getActiveAnimation(id, CCActiveAnimation::Opacity)->setRunState(CCActiveAnimation::Aborted, 1);
controller->animate(1, events.get());
EXPECT_TRUE(controller->hasActiveAnimation());
EXPECT_EQ(1, dummy.opacity());
controller->animate(2, events.get());
EXPECT_TRUE(!controller->hasActiveAnimation());
EXPECT_EQ(0.75, dummy.opacity());
}
}