android-12.1.0_r1/s

/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.view.animation.cts;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.atLeastOnce;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;

import android.app.Activity;
import android.app.Instrumentation;
import android.content.res.XmlResourceParser;
import android.os.SystemClock;
import android.util.AttributeSet;
import android.util.Xml;
import android.view.View;
import android.view.animation.AccelerateDecelerateInterpolator;
import android.view.animation.AccelerateInterpolator;
import android.view.animation.Animation;
import android.view.animation.Animation.AnimationListener;
import android.view.animation.AnimationUtils;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Interpolator;
import android.view.animation.Transformation;
import android.view.cts.R;

import androidx.test.InstrumentationRegistry;
import androidx.test.filters.LargeTest;
import androidx.test.filters.MediumTest;
import androidx.test.rule.ActivityTestRule;
import androidx.test.runner.AndroidJUnit4;

import com.android.compatibility.common.util.PollingCheck;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Test {@link Animation}.
 */
@MediumTest
@RunWith(AndroidJUnit4.class)
public class AnimationTest {
    private static final float COMPARISON_DELTA = 0.001f;

    /** It is defined in R.anim.accelerate_alpha */
    private static final int ACCELERATE_ALPHA_DURATION = 1000;

    /** It is defined in R.anim.decelerate_alpha */
    private static final int DECELERATE_ALPHA_DURATION = 2000;

    private static final int CANCELATION_TIMEOUT = 5000;

    private Instrumentation mInstrumentation;
    private Activity mActivity;

    @Rule
    public ActivityTestRule<AnimationTestCtsActivity> mActivityRule =
            new ActivityTestRule<>(AnimationTestCtsActivity.class);

    @Before
    public void setup() {
        mInstrumentation = InstrumentationRegistry.getInstrumentation();
        mActivity = mActivityRule.getActivity();
    }

    @Test
    public void testConstructor() {
        XmlResourceParser parser = mActivity.getResources().getAnimation(R.anim.alpha);
        AttributeSet attrs = Xml.asAttributeSet(parser);
        new Animation(mActivity, attrs) {
        };

        new Animation() {
        };
    }

    @Test
    public void testAccessInterpolator() {
        // check default interpolator
        MyAnimation myAnimation = new MyAnimation();
        Interpolator interpolator = myAnimation.getInterpolator();
        assertTrue(interpolator instanceof AccelerateDecelerateInterpolator); // issue 1561186.

        myAnimation.ensureInterpolator();
        assertSame(interpolator, myAnimation.getInterpolator());

        myAnimation.setInterpolator(null);
        assertNull(myAnimation.getInterpolator());
        myAnimation.ensureInterpolator();
        interpolator = myAnimation.getInterpolator();
        assertTrue(interpolator instanceof AccelerateDecelerateInterpolator);

        Animation animation = AnimationUtils.loadAnimation(mActivity, R.anim.decelerate_alpha);
        interpolator = animation.getInterpolator();
        assertNotNull(interpolator);
        assertTrue(interpolator instanceof DecelerateInterpolator);

        animation = AnimationUtils.loadAnimation(mActivity, R.anim.accelerate_alpha);
        interpolator = animation.getInterpolator();
        assertNotNull(interpolator);
        assertTrue(interpolator instanceof AccelerateInterpolator);
    }

    @Test
    public void testDefaultFill() {
        Animation animation = new Animation() {
        };
        assertTrue(animation.getFillBefore());
        assertFalse(animation.getFillAfter());
    }

    @Test
    public void testAccessFill() throws Throwable {
        View animWindow = mActivity.findViewById(R.id.anim_window);
        // XML file of R.anim.accelerate_alpha
        // <alpha xmlns:android="http://schemas.android.com/apk/res/android"
        //     android:interpolator="@android:anim/accelerate_interpolator"
        //     android:fromAlpha="0.1"
        //     android:toAlpha="0.9"
        //     android:duration="1000" />
        Animation animation = AnimationUtils.loadAnimation(mActivity, R.anim.accelerate_alpha);
        assertFalse(animation.isFillEnabled());
        assertTrue(animation.getFillBefore());
        assertFalse(animation.getFillAfter());

        AnimationTestUtils.assertRunAnimation(mInstrumentation, mActivityRule, animWindow,
                animation);

        // fillBefore and fillAfter are ignored when fillEnabled is false
        Transformation transformation = new Transformation();
        // check alpha before start
        animation.getTransformation(animation.getStartTime() - 1, transformation);
        float alpha = transformation.getAlpha();
        assertEquals(0.1f, alpha, COMPARISON_DELTA);  // issue 1698355

        transformation = new Transformation();
        // check alpha after the end
        animation.getTransformation(animation.getStartTime() + animation.getDuration() + 1,
                transformation);
        alpha = transformation.getAlpha();
        assertEquals(0.9f, alpha, COMPARISON_DELTA);  // issue 1698355

        animation.setFillEnabled(true);
        animation.setFillBefore(false);
        assertTrue(animation.isFillEnabled());
        assertFalse(animation.getFillBefore());
        assertFalse(animation.getFillAfter());
        AnimationTestUtils.assertRunAnimation(mInstrumentation, mActivityRule, animWindow,
                animation);

        transformation = new Transformation();
        animation.getTransformation(animation.getStartTime() - 1, transformation);
        alpha = transformation.getAlpha();
        assertEquals(1.0f, alpha, COMPARISON_DELTA);

        transformation = new Transformation();
        animation.getTransformation(animation.getStartTime() + animation.getDuration() + 1,
                transformation);
        alpha = transformation.getAlpha();
        assertEquals(1.0f, alpha, COMPARISON_DELTA);

        animation.setFillBefore(true);
        animation.setFillAfter(true);
        assertTrue(animation.isFillEnabled());
        assertTrue(animation.getFillBefore());
        assertTrue(animation.getFillAfter());
        AnimationTestUtils.assertRunAnimation(mInstrumentation, mActivityRule, animWindow,
                animation);

        transformation = new Transformation();
        animation.getTransformation(animation.getStartTime() - 1, transformation);
        alpha = transformation.getAlpha();
        assertEquals(0.1f, alpha, COMPARISON_DELTA);

        transformation = new Transformation();
        animation.getTransformation(animation.getStartTime() + animation.getDuration() + 1,
                transformation);
        alpha = transformation.getAlpha();
        assertEquals(0.9f, alpha, COMPARISON_DELTA);
    }

    @Test
    public void testComputeDurationHint() {
        // start offset is 0, duration is 2000, repeat count is 0.
        Animation animation = AnimationUtils.loadAnimation(mActivity, R.anim.decelerate_alpha);
        assertEquals(2000, animation.computeDurationHint());

        // start offset is 0, duration is 2000, repeat count is 2.
        animation.setRepeatCount(2);
        assertEquals(6000, animation.computeDurationHint());

        // start offset is 800, duration is 2000, repeat count is 2.
        animation.setStartOffset(800);
        assertEquals(8400, animation.computeDurationHint());
    }

    @Test
    public void testRepeatAnimation() throws Throwable {
        // check default repeatMode
        Animation animation = new Animation() {
        };
        assertEquals(Animation.RESTART, animation.getRepeatMode());

        final View animWindow = mActivity.findViewById(R.id.anim_window);

        // XML file of R.anim.decelerate_alpha
        // <alpha xmlns:android="http://schemas.android.com/apk/res/android"
        //      android:interpolator="@android:anim/decelerate_interpolator"
        //      android:fromAlpha="0.0"
        //      android:toAlpha="1.0"
        //      android:duration="2000" />
        final Animation anim = AnimationUtils.loadAnimation(mActivity, R.anim.decelerate_alpha);
        assertEquals(Animation.RESTART, animation.getRepeatMode());
        long duration = anim.getDuration();
        assertEquals(DECELERATE_ALPHA_DURATION, duration);
        // repeat count is 0, repeat mode does not make sense.
        AnimationTestUtils.assertRunAnimation(mInstrumentation, mActivityRule, animWindow, anim);

        // test repeat mode REVERSE
        anim.setRepeatCount(1);
        anim.setRepeatMode(Animation.REVERSE);
        // we have to PollingCheck the animation status on test thread,
        // it cannot be done on UI thread, so we invoke runOnUiThread method here.
        mActivityRule.runOnUiThread(() -> animWindow.startAnimation(anim));

        // check whether animation has started
        PollingCheck.waitFor(anim::hasStarted);

        Transformation transformation = new Transformation();
        long startTime = anim.getStartTime();
        anim.getTransformation(startTime, transformation);
        float alpha1 = transformation.getAlpha();
        assertEquals(0.0f, alpha1, COMPARISON_DELTA);

        anim.getTransformation(startTime + 1000, transformation);
        float alpha2 = transformation.getAlpha();

        anim.getTransformation(startTime + 2000, transformation);
        float alpha3 = transformation.getAlpha();
        assertEquals(1.0f, alpha3, COMPARISON_DELTA);

        // wait for animation has ended.
        // timeout is larger than duration, in case the system is sluggish
        PollingCheck.waitFor(duration * 2 + 1000, anim::hasEnded);

        // get start time of reversing.
        startTime = anim.getStartTime();
        anim.getTransformation(startTime + 3000, transformation);
        float alpha4 = transformation.getAlpha();

        anim.getTransformation(startTime + 4000, transformation);
        float alpha5 = transformation.getAlpha();
        assertEquals(0.0f, alpha5, COMPARISON_DELTA);

        // check decelerating delta alpha when reverse. alpha should change form 0.0f to 1.0f
        // and then from 1.0f to 0.0f
        float delta1 = alpha2 - alpha1;
        float delta2 = alpha3 - alpha2;
        // the animation plays backward
        float delta3 = alpha3 - alpha4;
        float delta4 = alpha4 - alpha5;
        assertTrue(delta1 > delta2);
        assertTrue(delta3 > delta4);

        // test repeat mode RESTART
        anim.setRepeatMode(Animation.RESTART);
        // we have to PollingCheck the animation status on test thread,
        // it cannot be done on UI thread, so we invoke runOnUiThread method here.
        mActivityRule.runOnUiThread(() -> animWindow.startAnimation(anim));

        // check whether animation has started
        PollingCheck.waitFor(anim::hasStarted);

        transformation = new Transformation();
        startTime = anim.getStartTime();
        anim.getTransformation(startTime, transformation);
        alpha1 = transformation.getAlpha();
        assertEquals(0.0f, alpha1, COMPARISON_DELTA);

        anim.getTransformation(startTime + 1000, transformation);
        alpha2 = transformation.getAlpha();

        anim.getTransformation(startTime + 2000, transformation);
        alpha3 = transformation.getAlpha();
        assertEquals(1.0f, alpha3, COMPARISON_DELTA);

        // wait for animation has ended.
        // timeout is larger than duration, in case the system is sluggish
        PollingCheck.waitFor(duration * 2 + 1000, anim::hasEnded);

        // get start time of restarting.
        startTime = anim.getStartTime();
        anim.getTransformation(startTime + 3000, transformation);
        alpha4 = transformation.getAlpha();

        anim.getTransformation(startTime + 4000, transformation);
        alpha5 = transformation.getAlpha();
        assertEquals(1.0f, alpha5, COMPARISON_DELTA);

        // check decelerating delta alpha when restart. alpha should change form 0.0f to 1.0f
        // and then from 0.0f to 1.0f again
        delta1 = alpha2 - 0.0f;
        delta2 = alpha3 - alpha2;
        // the animation restarts from the beginning
        delta3 = alpha4 - 0.0f;
        delta4 = alpha5 - alpha4;
        assertTrue(delta1 > delta2);
        assertTrue(delta3 > delta4);
    }

    @Test
    public void testAccessStartOffset() throws Throwable {
        final long startOffset = 800;
        // check default startOffset
        Animation animation = new Animation() {
        };
        assertEquals(0, animation.getStartOffset());

        View animWindow = mActivity.findViewById(R.id.anim_window);
        // XML file of R.anim.accelerate_alpha
        // <alpha xmlns:android="http://schemas.android.com/apk/res/android"
        //      android:interpolator="@android:anim/accelerate_interpolator"
        //      android:fromAlpha="0.1"
        //      android:toAlpha="0.9"
        //      android:duration="1000" />
        animation = AnimationUtils.loadAnimation(mActivity, R.anim.accelerate_alpha);
        animation.setStartOffset(startOffset);
        assertEquals(startOffset, animation.getStartOffset());

        AnimationTestUtils.assertRunAnimation(mInstrumentation, mActivityRule, animWindow,
                animation, ACCELERATE_ALPHA_DURATION + startOffset);

        Transformation transformation = new Transformation();
        long startTime = animation.getStartTime();
        animation.getTransformation(startTime, transformation);
        float alpha1 = transformation.getAlpha();
        assertEquals(0.1f, alpha1, COMPARISON_DELTA);

        animation.getTransformation(startTime + 400, transformation);
        float alpha2 = transformation.getAlpha();
        // alpha is 0.1f during start offset
        assertEquals(0.1f, alpha2, COMPARISON_DELTA);

        animation.getTransformation(startTime + startOffset, transformation);
        float alpha3 = transformation.getAlpha();
        // alpha is 0.1f during start offset
        assertEquals(0.1f, alpha3, COMPARISON_DELTA);

        animation.getTransformation(startTime + startOffset + 1, transformation);
        float alpha4 = transformation.getAlpha();
        // alpha is lager than 0.1f after start offset
        assertTrue(alpha4 > 0.1f);
    }

    @Test
    public void testRunAccelerateAlpha() throws Throwable {
        // check default startTime
        Animation animation = new Animation() {
        };
        assertEquals(Animation.START_ON_FIRST_FRAME, animation.getStartTime());

        long currentTime = AnimationUtils.currentAnimationTimeMillis();
        animation.setStartTime(currentTime);
        assertEquals(currentTime, animation.getStartTime());

        View animWindow = mActivity.findViewById(R.id.anim_window);

        // XML file of R.anim.accelerate_alpha
        // <alpha xmlns:android="http://schemas.android.com/apk/res/android"
        //      android:interpolator="@android:anim/accelerate_interpolator"
        //      android:fromAlpha="0.1"
        //      android:toAlpha="0.9"
        //      android:duration="1000" />
        Animation anim = AnimationUtils.loadAnimation(mActivity, R.anim.accelerate_alpha);
        assertEquals(Animation.START_ON_FIRST_FRAME, anim.getStartTime());
        assertFalse(anim.hasStarted());
        AnimationTestUtils.assertRunAnimation(mInstrumentation, mActivityRule, animWindow, anim);
    }

    @Test
    public void testGetTransformation() throws Throwable {
        final View animWindow = mActivity.findViewById(R.id.anim_window);

        // XML file of R.anim.accelerate_alpha
        // <alpha xmlns:android="http://schemas.android.com/apk/res/android"
        //      android:interpolator="@android:anim/accelerate_interpolator"
        //      android:fromAlpha="0.1"
        //      android:toAlpha="0.9"
        //      android:duration="1000" />
        final Animation anim = AnimationUtils.loadAnimation(mActivity, R.anim.accelerate_alpha);
        assertFalse(anim.hasStarted());

        // we have to PollingCheck the animation status on test thread,
        // it cannot be done on UI thread, so we invoke runOnUiThread method here.
        mActivityRule.runOnUiThread(() -> animWindow.startAnimation(anim));

        // check whether animation has started
        PollingCheck.waitFor(anim::hasStarted);

        // check transformation objects that is provided by the
        // caller and will be filled in by the animation.
        Transformation transformation = new Transformation();
        long startTime = anim.getStartTime();
        assertTrue(anim.getTransformation(startTime, transformation));
        float alpha1 = transformation.getAlpha();
        assertEquals(0.1f, alpha1, COMPARISON_DELTA);

        assertTrue(anim.getTransformation(startTime + 250, transformation));
        float alpha2 = transformation.getAlpha();

        assertTrue(anim.getTransformation(startTime + 500, transformation));
        float alpha3 = transformation.getAlpha();

        assertTrue(anim.getTransformation(startTime + 750, transformation));
        float alpha4 = transformation.getAlpha();

        // wait for animation has ended.
        // timeout is larger than duration, in case the system is sluggish
        PollingCheck.waitFor(2000, anim::hasEnded);

        assertFalse(anim.getTransformation(startTime + 1000, transformation));
        float alpha5 = transformation.getAlpha();
        assertEquals(0.9f, alpha5, COMPARISON_DELTA);

        // check decelerating delta alpha
        float delta1 = alpha2 - alpha1;
        float delta2 = alpha3 - alpha2;
        float delta3 = alpha4 - alpha3;
        float delta4 = alpha5 - alpha4;
        assertTrue(delta1 < delta2);
        assertTrue(delta2 < delta3);
        assertTrue(delta3 < delta4);
    }

    @Test
    public void testAccessZAdjustment() {
        // check default zAdjustment
        Animation animation = new Animation() {
        };
        assertEquals(Animation.ZORDER_NORMAL, animation.getZAdjustment());

        animation = AnimationUtils.loadAnimation(mActivity, R.anim.accelerate_alpha);
        assertEquals(Animation.ZORDER_NORMAL, animation.getZAdjustment());

        animation.setZAdjustment(Animation.ZORDER_TOP);
        assertEquals(Animation.ZORDER_TOP, animation.getZAdjustment());

        animation.setZAdjustment(Animation.ZORDER_BOTTOM);
        assertEquals(Animation.ZORDER_BOTTOM, animation.getZAdjustment());
    }

    @Test
    public void testInitialize() {
        Animation animation = new Animation() {
        };

        assertFalse(animation.isInitialized());
        animation.initialize(320, 480, 320, 480);
        assertTrue(animation.isInitialized());
    }

    @Test
    public void testResolveSize() {
        MyAnimation myAnimation = new MyAnimation();

        assertEquals(1.0f, myAnimation.resolveSize(Animation.ABSOLUTE, 1.0f, 0, 0),
                COMPARISON_DELTA);
        assertEquals(2.0f, myAnimation.resolveSize(Animation.ABSOLUTE, 2.0f, 0, 0),
                COMPARISON_DELTA);

        assertEquals(6.0f, myAnimation.resolveSize(Animation.RELATIVE_TO_SELF, 3.0f, 2, 0),
                COMPARISON_DELTA);
        assertEquals(9.0f, myAnimation.resolveSize(Animation.RELATIVE_TO_SELF, 3.0f, 3, 0),
                COMPARISON_DELTA);

        assertEquals(18.0f, myAnimation.resolveSize(Animation.RELATIVE_TO_PARENT, 3.0f, 0, 6),
                COMPARISON_DELTA);
        assertEquals(12.0f, myAnimation.resolveSize(Animation.RELATIVE_TO_PARENT, 3.0f, 0, 4),
                COMPARISON_DELTA);

        int unknownType = 7;
        assertEquals(8.0f, myAnimation.resolveSize(unknownType, 8.0f, 3, 4), COMPARISON_DELTA);
        assertEquals(10.0f, myAnimation.resolveSize(unknownType, 10.0f, 3, 4), COMPARISON_DELTA);
    }

    @Test
    public void testRestrictDuration() {
        Animation animation = new Animation() {
        };

        animation.setStartOffset(1000);
        animation.restrictDuration(500);
        assertEquals(500, animation.getStartOffset());
        assertEquals(0, animation.getDuration());
        assertEquals(0, animation.getRepeatCount());

        animation.setStartOffset(1000);
        animation.setDuration(1000);
        animation.restrictDuration(1500);
        assertEquals(500, animation.getDuration());

        animation.setStartOffset(1000);
        animation.setDuration(1000);
        animation.setRepeatCount(3);
        animation.restrictDuration(4500);
        assertEquals(1, animation.getRepeatCount());
    }

    @Test
    public void testScaleCurrentDuration() {
        Animation animation = new Animation() {
        };

        animation.setDuration(10);
        animation.scaleCurrentDuration(0);
        assertEquals(0, animation.getDuration());

        animation.setDuration(10);
        animation.scaleCurrentDuration(2);
        assertEquals(20, animation.getDuration());

        animation.setDuration(10);
        animation.scaleCurrentDuration(-1);
        assertEquals(-10, animation.getDuration());
    }

    @LargeTest
    @Test
    public void testSetAnimationListener() throws Throwable {
        final View animWindow = mActivity.findViewById(R.id.anim_window);

        // XML file of R.anim.accelerate_alpha
        // <alpha xmlns:android="http://schemas.android.com/apk/res/android"
        //      android:interpolator="@android:anim/accelerate_interpolator"
        //      android:fromAlpha="0.1"
        //      android:toAlpha="0.9"
        //      android:duration="1000" />
        final Animation anim = AnimationUtils.loadAnimation(mActivity, R.anim.accelerate_alpha);
        final AnimationListener listener = mock(AnimationListener.class);
        anim.setAnimationListener(listener);
        verifyZeroInteractions(listener);

        AnimationTestUtils.assertRunAnimation(mInstrumentation, mActivityRule, animWindow, anim);
        verify(listener, times(1)).onAnimationStart(anim);
        verify(listener, times(1)).onAnimationEnd(anim);
        verify(listener, never()).onAnimationRepeat(anim);

        reset(listener);
        anim.setRepeatCount(2);
        anim.setRepeatMode(Animation.REVERSE);

        AnimationTestUtils.assertRunAnimation(mInstrumentation, mActivityRule, animWindow, anim,
                3 * ACCELERATE_ALPHA_DURATION);
        verify(listener, times(1)).onAnimationStart(anim);
        verify(listener, times(2)).onAnimationRepeat(anim);
        verify(listener, times(1)).onAnimationEnd(anim);

        reset(listener);
        // onAnimationEnd will not be invoked and animation should not end
        anim.setRepeatCount(Animation.INFINITE);

        mActivityRule.runOnUiThread(() -> animWindow.startAnimation(anim));
        // Verify that our animation doesn't call listener's onAnimationEnd even after a long
        // period of time. We just sleep and then verify what's happened with the listener.
        SystemClock.sleep(4 * ACCELERATE_ALPHA_DURATION);

        verify(listener, times(1)).onAnimationStart(anim);
        verify(listener, atLeastOnce()).onAnimationRepeat(anim);
        verify(listener, never()).onAnimationEnd(anim);
    }

    @Test
    public void testStart() {
        Animation animation = AnimationUtils.loadAnimation(mActivity, R.anim.accelerate_alpha);
        animation.setStartTime(0);

        animation.start();
        assertEquals(Animation.START_ON_FIRST_FRAME, animation.getStartTime());
    }

    @Test
    public void testStartNow() {
        Animation animation = AnimationUtils.loadAnimation(mActivity, R.anim.accelerate_alpha);
        animation.setStartTime(0);

        long currentTime = AnimationUtils.currentAnimationTimeMillis();
        animation.startNow();
        assertEquals(currentTime, animation.getStartTime(), 100);
    }

    @Test
    public void testWillChangeBounds() {
        Animation animation = new Animation() {
        };

        assertTrue(animation.willChangeBounds());
    }

    @Test
    public void testWillChangeTransformationMatrix() {
        Animation animation = new Animation() {
        };

        assertTrue(animation.willChangeTransformationMatrix());
    }

    @Test
    public void testClone() throws CloneNotSupportedException {
        MyAnimation myAnimation = new MyAnimation();
        myAnimation.setDuration(3000);
        myAnimation.setFillAfter(true);
        myAnimation.setFillBefore(false);
        myAnimation.setFillEnabled(true);
        myAnimation.setStartTime(1000);
        myAnimation.setRepeatCount(10);
        myAnimation.setRepeatMode(Animation.REVERSE);

        Animation cloneAnimation = myAnimation.clone();
        assertNotSame(myAnimation, cloneAnimation);
        assertEquals(myAnimation.getDuration(), cloneAnimation.getDuration());
        assertEquals(myAnimation.getFillAfter(), cloneAnimation.getFillAfter());
        assertEquals(myAnimation.getFillBefore(), cloneAnimation.getFillBefore());
        assertEquals(myAnimation.isFillEnabled(), cloneAnimation.isFillEnabled());
        assertEquals(myAnimation.getStartOffset(), cloneAnimation.getStartOffset());
        assertEquals(myAnimation.getRepeatCount(), cloneAnimation.getRepeatCount());
        assertEquals(myAnimation.getRepeatMode(), cloneAnimation.getRepeatMode());
    }

    @Test
    public void testCancelImmediately() throws Throwable {
        MyAnimation anim = new MyAnimation();
        final CountDownLatch latch1 = new CountDownLatch(1);
        runCanceledAnimation(anim, latch1, false, false);
        assertTrue(latch1.await(CANCELATION_TIMEOUT, TimeUnit.MILLISECONDS));
        assertFalse(anim.isStillAnimating());
    }

    @Test
    public void testRepeatingCancelImmediately() throws Throwable {
        MyAnimation anim = new MyAnimation();
        final CountDownLatch latch2 = new CountDownLatch(1);
        runCanceledAnimation(anim, latch2, true, false);
        assertTrue(latch2.await(CANCELATION_TIMEOUT, TimeUnit.MILLISECONDS));
        assertFalse(anim.isStillAnimating());
    }

    @Test
    public void testCancelDelayed() throws Throwable {
        MyAnimation anim = new MyAnimation();
        final CountDownLatch latch3 = new CountDownLatch(1);
        runCanceledAnimation(anim, latch3, false, true);
        assertTrue(latch3.await(CANCELATION_TIMEOUT, TimeUnit.MILLISECONDS));
        assertFalse(anim.isStillAnimating());
    }

    @Test
    public void testRepeatingCancelDelayed() throws Throwable {
        MyAnimation anim = new MyAnimation();
        final CountDownLatch latch4 = new CountDownLatch(1);
        runCanceledAnimation(anim, latch4, true, true);
        assertTrue(latch4.await(CANCELATION_TIMEOUT, TimeUnit.MILLISECONDS));
        assertFalse(anim.isStillAnimating());
    }

    private void runCanceledAnimation(final MyAnimation anim, final CountDownLatch latch,
            final boolean repeating, final boolean delayed) throws Throwable {
        // The idea behind this test is that canceling an Animation should result in
        // it ending, which means not having its getTransformation() method called
        // anymore. The trick is that cancel() will still allow one more frame to run,
        // so we have to insert some delay between when we cancel and when we can check
        // whether it is still animating.
        final View view = mActivity.findViewById(R.id.anim_window);
        mActivityRule.runOnUiThread(() -> {
            anim.setDuration(delayed ? 300 : 200);
            if (repeating) {
                anim.setRepeatCount(Animation.INFINITE);
            }
            view.startAnimation(anim);
            if (!delayed) {
                anim.cancel();
            } else {
                view.postDelayed(anim::cancel, 100);
            }
            view.postDelayed(() -> {
                anim.setStillAnimating(false);
                view.postDelayed(latch::countDown, 200);
            }, delayed ? 300 : 200);
        });
    }

    private class MyAnimation extends Animation {
        boolean mStillAnimating = false;

        @Override
        protected void ensureInterpolator() {
            super.ensureInterpolator();
        }

        @Override
        protected float resolveSize(int type, float value, int size, int parentSize) {
            return super.resolveSize(type, value, size, parentSize);
        }

        @Override
        protected Animation clone() throws CloneNotSupportedException {
            return super.clone();
        }

        public void setStillAnimating(boolean value) {
            mStillAnimating = value;
        }

        public boolean isStillAnimating() {
            return mStillAnimating;
        }

        @Override
        public boolean getTransformation(long currentTime, Transformation outTransformation) {
            mStillAnimating = true;
            return super.getTransformation(currentTime, outTransformation);
        }
    }
}