Handle exception in newly spawned thread in the test

*/

package android.animation;

import static junit.framework.Assert.assertEquals;

import static junit.framework.Assert.assertFalse;

import static junit.framework.Assert.assertNotNull;

import static junit.framework.Assert.assertTrue;

import android.os.Handler;

import android.os.Looper;

import android.os.Message;

import android.os.SystemClock;

import android.test.ActivityInstrumentationTestCase2;

import android.test.suitebuilder.annotation.SmallTest;

import android.support.test.annotation.UiThreadTest;

import android.support.test.filters.MediumTest;

import android.support.test.rule.ActivityTestRule;

import android.support.test.runner.AndroidJUnit4;

import android.view.Choreographer;

import android.view.animation.LinearInterpolator;

import org.junit.After;

import org.junit.Before;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;

import java.util.ArrayList;

import static android.test.MoreAsserts.assertNotEqual;

public class ValueAnimatorTests extends ActivityInstrumentationTestCase2<BasicAnimatorActivity> {

@RunWith(AndroidJUnit4.class)

@MediumTest

public class ValueAnimatorTests {

    private static final long WAIT_TIME_OUT = 5000;

    private ValueAnimator a1;

    private ValueAnimator a2;

    private final static long DEFAULT_FRAME_INTERVAL = 5; //ms

    private final static long COMMIT_DELAY = 3; //ms

    public ValueAnimatorTests() {

        super(BasicAnimatorActivity.class);

    }

    private ActivityTestRule<BasicAnimatorActivity> mActivityRule =

            new ActivityTestRule<>(BasicAnimatorActivity.class);

    @Override

    @Before

    public void setUp() throws Exception {

        super.setUp();

        a1 = ValueAnimator.ofFloat(A1_START_VALUE, A1_END_VALUE).setDuration(300);

        a2 = ValueAnimator.ofInt(A2_START_VALUE, A2_END_VALUE).setDuration(500);

    }

    @Override

    @After

    public void tearDown() throws Exception {

        a1 = null;

        a2 = null;

        super.tearDown();

    }

    @SmallTest

    @Test

    public void testStartDelay() throws Throwable {

        final ValueAnimator a = ValueAnimator.ofFloat(5f, 20f);

        assertEquals(a.getStartDelay(), 0);

        a.addUpdateListener(listener);

        final long[] startTime = new long[1];

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // Test the time between isRunning() and isStarted()

        });

        Thread.sleep(a.getTotalDuration());

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertTrue(listener.wasRunning);

        });

        Thread.sleep(a.getTotalDuration());

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(a.isStarted());

        });

    }

    @SmallTest

    @Test

    public void testListenerCallbacks() throws Throwable {

        final MyListener l1 = new MyListener();

        final MyListener l2 = new MyListener();

        assertFalse(l2.cancelCalled);

        assertFalse(l2.endCalled);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                a1.start();

        Thread.sleep(POLL_INTERVAL);

        wait += POLL_INTERVAL;

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(l1.cancelCalled);

        });

        while (wait < a2.getStartDelay()) {

            runTestOnUiThread(new Runnable() {

            mActivityRule.runOnUiThread(new Runnable() {

                @Override

                public void run() {

                    // Make sure a2's start listener isn't called during start delay.

        long delay = Math.max(a1.getTotalDuration(), a2.getTotalDuration()) + TOLERANCE;

        Thread.sleep(delay);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // a1 is canceled.

        });

    }

    @SmallTest

    @Test

    public void testIsStarted() throws Throwable {

        assertFalse(a1.isStarted());

        assertFalse(a2.isStarted());

        a1.setStartDelay(startDelay);

        final long[] startTime = new long[1];

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                a1.start();

        while (delayMs < startDelay) {

            Thread.sleep(POLL_INTERVAL);

            delayMs += POLL_INTERVAL;

            runTestOnUiThread(new Runnable() {

            mActivityRule.runOnUiThread(new Runnable() {

                @Override

                public void run() {

                    if (SystemClock.uptimeMillis() - startTime[0] < startDelay) {

        }

        Thread.sleep(startDelay);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertTrue(a1.isRunning());

        long delay = Math.max(a1.getTotalDuration(), a2.getTotalDuration()) * 2;

        Thread.sleep(delay);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(a1.isStarted());

        });

    }

    @SmallTest

    @Test

    public void testPause() throws Throwable {

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(a1.isPaused());

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertTrue(a1.isRunning());

        });

        Thread.sleep(a2.getTotalDuration());

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // By this time, a2 should have finished, and a1 is still paused

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertTrue(a1.isRunning());

        });

        Thread.sleep(a1.getTotalDuration());

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // a1 should finish by now.

    }

    @SmallTest

    @Test

    public void testPauseListener() throws Throwable {

        MyPauseListener l1 = new MyPauseListener();

        MyPauseListener l2 = new MyPauseListener();

        assertFalse(l2.pauseCalled);

        assertFalse(l2.resumeCalled);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                a1.start();

        // Only a1's pause listener should be called.

        assertTrue(l1.pauseCalled);

        assertFalse(l1.resumeCalled);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                a1.resume();

        assertFalse(l2.resumeCalled);

    }

    @SmallTest

    @Test

    public void testResume() throws Throwable {

        final MyUpdateListener l1 = new MyUpdateListener();

        final long totalDuration = a1.getTotalDuration();

        final long[] lastUpdate = new long[1];

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                a1.start();

        Thread.sleep(totalDuration / 2);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertTrue(l1.firstRunningFrameTime > 0);

        Thread.sleep(totalDuration);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // There should be no update after pause()

        do {

            Thread.sleep(POLL_INTERVAL);

            runTestOnUiThread(new Runnable() {

            mActivityRule.runOnUiThread(new Runnable() {

                @Override

                public void run() {

                    assertTrue(l1.lastUpdateTime > lastUpdate[0]);

        assertTrue(Math.abs(entireSpan - frameDelta) < TOLERANCE);

    }

    @SmallTest

    @Test

    public void testEnd() throws Throwable {

        final MyListener l1 = new MyListener();

        final MyListener l2 = new MyListener();

            }

        });

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(l1.cancelCalled);

            }

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                a1.end();

            }

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // Calling cancel from onAnimationEnd will be ignored.

    }

    @SmallTest

    @Test

    public void testEndValue() throws Throwable {

        final MyListener l1 = new MyListener();

        a1.addListener(l1);

        final MyListener l2 = new MyListener();

        a2.addListener(l2);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                a1.start();

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // Animation has started but not finished, check animated values against end values

        Thread.sleep(a1.getTotalDuration());

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(l1.cancelCalled);

        });

    }

    @SmallTest

    @Test

    public void testUpdateListener() throws InterruptedException {

        final MyFrameCallbackProvider provider = new MyFrameCallbackProvider();

                long currentTime = SystemClock.uptimeMillis();

                long frameDelay = provider.getFrameDelay();

                if (lastUpdateTime > 0) {

                    // Error tolerance here is one frame.

                    assertTrue((currentTime - lastUpdateTime) < frameDelay * 2);

                    // Error tolerance here is 3 frame.

                    assertTrue((currentTime - lastUpdateTime) < frameDelay * 4);

                } else {

                    // First frame:

                    assertTrue(listener.startCalled);

                    assertTrue(listener.startTime > 0);

                    assertTrue(currentTime - listener.startTime < frameDelay * 2);

                    assertTrue(currentTime - listener.startTime < frameDelay * 4);

                }

                super.onAnimationUpdate(animation);

            }

        assertTrue(a1.isStarted());

        Thread.sleep(a1.getTotalDuration() + TOLERANCE);

        // Finished by now.

        if (provider.mAssertionError != null) {

            throw provider.mAssertionError;

        }

        assertFalse(a1.isStarted());

        assertTrue(listener.endTime > 0);

    }

    @SmallTest

    @Test

    public void testConcurrentModification() throws Throwable {

        // Attempt to modify list of animations as the list is being iterated

        final ValueAnimator a0 = ValueAnimator.ofInt(100, 200).setDuration(500);

        };

        a2.addListener(listener);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                a0.start();

                a4.start();

            }

        });

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertTrue(a0.isStarted());

            }

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // End the animator that should be in the middle of the list.

        assertFalse(a4.isStarted());

    }

    @SmallTest

    @Test

    public void testSeek() throws Throwable {

        final MyListener l1 = new MyListener();

        final MyListener l2 = new MyListener();

        a1.setInterpolator(interpolator);

        a2.setInterpolator(interpolator);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(a1.isStarted());

        Thread.sleep(POLL_INTERVAL);

        // Start animation and seek during the animation.

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(a1.isStarted());

        Thread.sleep(POLL_INTERVAL);

        final float halfwayFraction = 0.5f;

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertTrue(l1.startCalled);

        Thread.sleep(POLL_INTERVAL);

        // Check that seeking during running doesn't change animation's internal state

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertTrue(l1.startCalled);

        long wait = Math.max(a1.getTotalDuration(), a2.getTotalDuration());

        Thread.sleep(wait);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // Verify that the animators have finished.

        // Re-start animator a1 after it ends normally, and check that seek value from last run

        // does not affect the new run.

        updateListener1.reset();

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                a1.start();

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertTrue(updateListener1.wasRunning);

    }

    @SmallTest

    @Test

    public void testSeekWhileRunning() throws Throwable {

        // Seek one animator to the beginning and the other one to the end when they are running.

        final MyListener l1 = new MyListener();

        final MyListener l2 = new MyListener();

        a1.addListener(l1);

        a2.addListener(l2);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(l1.startCalled);

            }

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(l1.endCalled);

            }

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // Check that a2 has finished due to the seeking, but a1 hasn't finished.

        });

        Thread.sleep(a1.getTotalDuration());

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // By now a1 should finish also.

        });

    }

    @SmallTest

    @Test

    public void testEndBeforeStart() throws Throwable {

        // This test calls two animators that are not yet started. One animator has completed a

        // previous run but hasn't started since then, the other one has never run. When end() is

        // First start a1's first run.

        final MyListener normalEndingListener = new MyListener();

        a1.addListener(normalEndingListener);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(a1.isStarted());

        Thread.sleep(a1.getTotalDuration() + POLL_INTERVAL);

        // a1 should have finished by now.

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // Call end() on both a1 and a2 without calling start()

        });

    }

    @SmallTest

    @Test

    public void testZeroDuration() throws Throwable {

        // Run two animators with zero duration, with one running forward and the other one

        // backward. Check that the animations start and finish with the correct end fractions.

        a1.addListener(l1);

        a2.addListener(l2);

        a3.addListener(l3);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(l1.startCalled);

            }

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                // Check that the animators have started and finished with the right values.

        });

    }

    @SmallTest

    @Test

    public void testZeroScale() throws Throwable {

        // Test whether animations would end properly when the scale is forced to be zero

        float scale = ValueAnimator.getDurationScale();

        a1.addListener(l1);

        a2.addListener(l2);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertFalse(l1.startCalled);

        });

        Thread.sleep(POLL_INTERVAL);

        runTestOnUiThread(new Runnable() {

        mActivityRule.runOnUiThread(new Runnable() {

            @Override

            public void run() {

                assertTrue(l1.startCalled);

        ValueAnimator.setDurationScale(scale);

    }