/*
 * Copyright (C) 2020 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.server.wm;

import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN;
import static android.server.wm.WindowInsetsAnimationControllerTests.ControlListener.Event.CANCELLED;
import static android.server.wm.WindowInsetsAnimationControllerTests.ControlListener.Event.FINISHED;
import static android.server.wm.WindowInsetsAnimationControllerTests.ControlListener.Event.READY;
import static android.server.wm.WindowInsetsAnimationUtils.INSETS_EVALUATOR;
import static android.view.WindowInsets.Type.ime;
import static android.view.WindowInsets.Type.navigationBars;
import static android.view.WindowInsets.Type.statusBars;

import static androidx.test.internal.runner.junit4.statement.UiThreadStatement.runOnUiThread;
import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;

import static com.android.cts.mockime.ImeEventStreamTestUtils.editorMatcher;
import static com.android.cts.mockime.ImeEventStreamTestUtils.expectEvent;

import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.hasItem;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;
import static org.hamcrest.Matchers.sameInstance;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeFalse;
import static org.junit.Assume.assumeThat;
import static org.junit.Assume.assumeTrue;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.app.Instrumentation;
import android.graphics.Insets;
import android.os.CancellationSignal;
import android.platform.test.annotations.Presubmit;
import android.server.wm.WindowInsetsAnimationTestBase.TestActivity;
import android.util.Log;
import android.view.View;
import android.view.WindowInsets;
import android.view.WindowInsetsAnimation;
import android.view.WindowInsetsAnimation.Callback;
import android.view.WindowInsetsAnimationControlListener;
import android.view.WindowInsetsAnimationController;
import android.view.WindowInsetsController.OnControllableInsetsChangedListener;
import android.view.animation.AccelerateInterpolator;
import android.view.animation.DecelerateInterpolator;
import android.view.animation.Interpolator;
import android.view.animation.LinearInterpolator;
import android.view.inputmethod.InputMethodManager;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import com.android.cts.mockime.ImeEventStream;
import com.android.cts.mockime.ImeSettings;
import com.android.cts.mockime.MockImeSession;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.rules.ErrorCollector;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameter;
import org.junit.runners.Parameterized.Parameters;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

/**
 * Test whether {@link android.view.WindowInsetsController#controlWindowInsetsAnimation} properly
 * works.
 *
 * Build/Install/Run:
 *     atest CtsWindowManagerDeviceTestCases:WindowInsetsAnimationControllerTests
 */
//TODO(b/159167851) @Presubmit
@RunWith(Parameterized.class)
public class WindowInsetsAnimationControllerTests extends WindowManagerTestBase {

    TestActivity mActivity;
    View mRootView;
    ControlListener mListener;
    CancellationSignal mCancellationSignal = new CancellationSignal();
    Interpolator mInterpolator;
    boolean mOnProgressCalled;
    private ValueAnimator mAnimator;
    List<VerifyingCallback> mCallbacks = new ArrayList<>();
    private boolean mLossOfControlExpected;

    public LimitedErrorCollector mErrorCollector = new LimitedErrorCollector();

    /**
     * {@link MockImeSession} used when {@link #mType} is
     * {@link android.view.WindowInsets.Type#ime()}.
     */
    @Nullable
    private MockImeSession mMockImeSession;

    @Parameter(0)
    public int mType;

    @Parameter(1)
    public String mTypeDescription;

    @Parameters(name= "{1}")
    public static Object[][] types() {
        return new Object[][] {
                { statusBars(), "statusBars" },
                { ime(), "ime" },
                { navigationBars(), "navigationBars" }
        };
    }

    @Before
    public void setUpWindowInsetsAnimationControllerTests() throws Throwable {
        assumeFalse(
                "In Automotive, auxiliary inset changes can happen when IME inset changes, so "
                        + "allow Automotive skip IME inset animation tests.",
                isCar() && mType == ime());

        final ImeEventStream mockImeEventStream;
        if (mType == ime()) {
            final Instrumentation instrumentation = getInstrumentation();
            assumeThat(MockImeSession.getUnavailabilityReason(instrumentation.getContext()),
                    nullValue());

            // For the best test stability MockIme should be selected before launching TestActivity.
            mMockImeSession = MockImeSession.create(
                    instrumentation.getContext(), instrumentation.getUiAutomation(),
                    new ImeSettings.Builder());
            mockImeEventStream = mMockImeSession.openEventStream();
        } else {
            mockImeEventStream = null;
        }

        mActivity = startActivityInWindowingMode(TestActivity.class, WINDOWING_MODE_FULLSCREEN);
        mRootView = mActivity.getWindow().getDecorView();
        mListener = new ControlListener(mErrorCollector);
        assumeTestCompatibility();

        if (mockImeEventStream != null) {
            // TestActivity has a focused EditText. Hence MockIme should receive onStartInput() for
            // that EditText within a reasonable time.
            expectEvent(mockImeEventStream,
                    editorMatcher("onStartInput", mActivity.getEditTextMarker()),
                    TimeUnit.SECONDS.toMillis(10));
        }
        awaitControl(mType);
    }

    @After
    public void tearDown() throws Throwable {
        runOnUiThread(() -> {});  // Fence to make sure we dispatched everything.
        mCallbacks.forEach(VerifyingCallback::assertNoPendingAnimations);

        // Unregistering VerifyingCallback as tearing down the MockIme also triggers UI events,
        // which can trigger assertion failures in VerifyingCallback otherwise.
        runOnUiThread(() -> {
            mCallbacks.clear();
            if (mRootView != null) {
                mRootView.setWindowInsetsAnimationCallback(null);
            }
        });

        // Now it should be safe to reset the IME to the default one.
        if (mMockImeSession != null) {
            mMockImeSession.close();
            mMockImeSession = null;
        }
        mErrorCollector.verify();
    }

    private void assumeTestCompatibility() {
        if (mType == navigationBars() || mType == statusBars()) {
            assumeTrue(Insets.NONE
                    != mRootView.getRootWindowInsets().getInsetsIgnoringVisibility(mType));
        }
    }

    private void awaitControl(int type) throws Throwable {
        CountDownLatch control = new CountDownLatch(1);
        OnControllableInsetsChangedListener listener = (controller, controllableTypes) -> {
            if ((controllableTypes & type) != 0)
                control.countDown();
        };
        runOnUiThread(() -> mRootView.getWindowInsetsController()
                .addOnControllableInsetsChangedListener(listener));
        try {
            if (!control.await(10, TimeUnit.SECONDS)) {
                fail("Timeout waiting for control of " + type);
            }
        } finally {
            runOnUiThread(() -> mRootView.getWindowInsetsController()
                    .removeOnControllableInsetsChangedListener(listener)
            );
        }
    }

    private void retryIfCancelled(ThrowableThrowingRunnable test) throws Throwable {
        try {
            mErrorCollector.verify();
            test.run();
        } catch (CancelledWhileWaitingForReadyException e) {
            // Deflake cancellations waiting for ready - we'll reset state and try again.
            runOnUiThread(() -> {
                mCallbacks.clear();
                if (mRootView != null) {
                    mRootView.setWindowInsetsAnimationCallback(null);
                }
            });
            mErrorCollector = new LimitedErrorCollector();
            mListener = new ControlListener(mErrorCollector);
            awaitControl(mType);
            test.run();
        }
    }

    @Presubmit
    @Test
    public void testControl_andCancel() throws Throwable {
        retryIfCancelled(() -> {
            runOnUiThread(() -> {
                setupAnimationListener();
                mRootView.getWindowInsetsController().controlWindowInsetsAnimation(mType, 0,
                        null, mCancellationSignal, mListener);
            });

            mListener.awaitAndAssert(READY);

            runOnUiThread(() -> {
                mCancellationSignal.cancel();
            });

            mListener.awaitAndAssert(CANCELLED);
            mListener.assertWasNotCalled(FINISHED);
        });
    }

    @Test
    public void testControl_andImmediatelyCancel() throws Throwable {
        retryIfCancelled(() -> {
            runOnUiThread(() -> {
                setupAnimationListener();
                mRootView.getWindowInsetsController().controlWindowInsetsAnimation(mType, 0,
                        null, mCancellationSignal, mListener);
                mCancellationSignal.cancel();
            });

            mListener.assertWasCalled(CANCELLED);
            mListener.assertWasNotCalled(READY);
            mListener.assertWasNotCalled(FINISHED);
        });
    }

    @Presubmit
    @Test
    public void testControl_immediately_show() throws Throwable {
        retryIfCancelled(() -> {
            setVisibilityAndWait(mType, false);

            runOnUiThread(() -> {
                setupAnimationListener();
                mRootView.getWindowInsetsController().controlWindowInsetsAnimation(mType, 0,
                        null, null, mListener);
            });

            mListener.awaitAndAssert(READY);

            runOnUiThread(() -> {
                mListener.mController.finish(true);
            });

            mListener.awaitAndAssert(FINISHED);
            mListener.assertWasNotCalled(CANCELLED);
        });
    }

    @Presubmit
    @Test
    public void testControl_immediately_hide() throws Throwable {
        retryIfCancelled(() -> {
            setVisibilityAndWait(mType, true);

            runOnUiThread(() -> {
                setupAnimationListener();
                mRootView.getWindowInsetsController().controlWindowInsetsAnimation(mType, 0,
                        null, null, mListener);
            });

            mListener.awaitAndAssert(READY);

            runOnUiThread(() -> {
                mListener.mController.finish(false);
            });

            mListener.awaitAndAssert(FINISHED);
            mListener.assertWasNotCalled(CANCELLED);
        });
    }

    @Presubmit
    @Test
    public void testControl_transition_show() throws Throwable {
        retryIfCancelled(() -> {
            setVisibilityAndWait(mType, false);

            runOnUiThread(() -> {
                setupAnimationListener();
                mRootView.getWindowInsetsController().controlWindowInsetsAnimation(mType, 0,
                        null, null, mListener);
            });

            mListener.awaitAndAssert(READY);

            runTransition(true);

            mListener.awaitAndAssert(FINISHED);
            mListener.assertWasNotCalled(CANCELLED);
        });
    }

    @Presubmit
    @Test
    public void testControl_transition_hide() throws Throwable {
        retryIfCancelled(() -> {
            setVisibilityAndWait(mType, true);

            runOnUiThread(() -> {
                setupAnimationListener();
                mRootView.getWindowInsetsController().controlWindowInsetsAnimation(mType, 0,
                        null, null, mListener);
            });

            mListener.awaitAndAssert(READY);

            runTransition(false);

            mListener.awaitAndAssert(FINISHED);
            mListener.assertWasNotCalled(CANCELLED);
        });
    }

    @Presubmit
    @Test
    public void testControl_transition_show_interpolator() throws Throwable {
        retryIfCancelled(() -> {
            mInterpolator = new DecelerateInterpolator();
            setVisibilityAndWait(mType, false);

            runOnUiThread(() -> {
                setupAnimationListener();
                mRootView.getWindowInsetsController().controlWindowInsetsAnimation(mType, 0,
                        mInterpolator, null, mListener);
            });

            mListener.awaitAndAssert(READY);

            runTransition(true);

            mListener.awaitAndAssert(FINISHED);
            mListener.assertWasNotCalled(CANCELLED);
        });
    }

    @Presubmit
    @Test
    public void testControl_transition_hide_interpolator() throws Throwable {
        retryIfCancelled(() -> {
            mInterpolator = new AccelerateInterpolator();
            setVisibilityAndWait(mType, true);

            runOnUiThread(() -> {
                setupAnimationListener();
                mRootView.getWindowInsetsController().controlWindowInsetsAnimation(mType, 0,
                        mInterpolator, null, mListener);
            });

            mListener.awaitAndAssert(READY);

            runTransition(false);

            mListener.awaitAndAssert(FINISHED);
            mListener.assertWasNotCalled(CANCELLED);
        });
    }

    @Test
    public void testControl_andLoseControl() throws Throwable {
        retryIfCancelled(() -> {
            mInterpolator = new AccelerateInterpolator();
            setVisibilityAndWait(mType, true);

            runOnUiThread(() -> {
                setupAnimationListener();
                mRootView.getWindowInsetsController().controlWindowInsetsAnimation(mType, 0,
                        mInterpolator, null, mListener);
            });

            mListener.awaitAndAssert(READY);

            runTransition(false, TimeUnit.MINUTES.toMillis(5));
            runOnUiThread(() -> {
                mLossOfControlExpected = true;
            });
            launchHomeActivityNoWait();

            mListener.awaitAndAssert(CANCELLED);
            mListener.assertWasNotCalled(FINISHED);
        });
    }

    @Presubmit
    @Test
    public void testImeControl_isntInterruptedByStartingInput() throws Throwable {
        if (mType != ime()) {
            return;
        }

        retryIfCancelled(() -> {
            setVisibilityAndWait(mType, false);

            runOnUiThread(() -> {
                setupAnimationListener();
                mRootView.getWindowInsetsController().controlWindowInsetsAnimation(mType, 0,
                        null, null, mListener);
            });

            mListener.awaitAndAssert(READY);

            runTransition(true);
            runOnUiThread(() -> {
                mActivity.getSystemService(InputMethodManager.class).restartInput(
                        mActivity.mEditor);
            });

            mListener.awaitAndAssert(FINISHED);
            mListener.assertWasNotCalled(CANCELLED);
        });
    }

    private void setupAnimationListener() {
        WindowInsets initialInsets = mActivity.mLastWindowInsets;
        VerifyingCallback callback = new VerifyingCallback(
                new Callback(Callback.DISPATCH_MODE_STOP) {
            @Override
            public void onPrepare(@NonNull WindowInsetsAnimation animation) {
                mErrorCollector.checkThat("onPrepare",
                        mActivity.mLastWindowInsets.getInsets(mType),
                        equalTo(initialInsets.getInsets(mType)));
            }

            @NonNull
            @Override
            public WindowInsetsAnimation.Bounds onStart(
                    @NonNull WindowInsetsAnimation animation,
                    @NonNull WindowInsetsAnimation.Bounds bounds) {
                mErrorCollector.checkThat("onStart",
                        mActivity.mLastWindowInsets, not(equalTo(initialInsets)));
                mErrorCollector.checkThat("onStart",
                        animation.getInterpolator(), sameInstance(mInterpolator));
                return bounds;
            }

            @NonNull
            @Override
            public WindowInsets onProgress(@NonNull WindowInsets insets,
                    @NonNull List<WindowInsetsAnimation> runningAnimations) {
                mOnProgressCalled = true;
                if (mAnimator != null) {
                    float fraction = runningAnimations.get(0).getFraction();
                    mErrorCollector.checkThat(
                            String.format(Locale.US, "onProgress(%.2f)", fraction),
                            insets.getInsets(mType), equalTo(mAnimator.getAnimatedValue()));
                    mErrorCollector.checkThat("onProgress",
                            fraction, equalTo(mAnimator.getAnimatedFraction()));

                    Interpolator interpolator =
                            mInterpolator != null ? mInterpolator
                                    : new LinearInterpolator();
                    mErrorCollector.checkThat("onProgress",
                            runningAnimations.get(0).getInterpolatedFraction(),
                            equalTo(interpolator.getInterpolation(
                                    mAnimator.getAnimatedFraction())));
                }
                return insets;
            }

            @Override
            public void onEnd(@NonNull WindowInsetsAnimation animation) {
                mRootView.setWindowInsetsAnimationCallback(null);
            }
        });
        mCallbacks.add(callback);
        mRootView.setWindowInsetsAnimationCallback(callback);
    }

    private void runTransition(boolean show) throws Throwable {
        runTransition(show, 1000);
    }

    private void runTransition(boolean show, long durationMillis) throws Throwable {
        runOnUiThread(() -> {
            mAnimator = ValueAnimator.ofObject(
                    INSETS_EVALUATOR,
                    show ? mListener.mController.getHiddenStateInsets()
                            : mListener.mController.getShownStateInsets(),
                    show ? mListener.mController.getShownStateInsets()
                            : mListener.mController.getHiddenStateInsets()
            );
            mAnimator.setDuration(durationMillis);
            mAnimator.addUpdateListener((animator1) -> {
                if (!mListener.mController.isReady()) {
                    // Lost control - Don't crash the instrumentation below.
                    if (!mLossOfControlExpected) {
                        mErrorCollector.addError(new AssertionError("Unexpectedly lost control."));
                    }
                    mAnimator.cancel();
                    return;
                }
                Insets insets = (Insets) mAnimator.getAnimatedValue();
                mOnProgressCalled = false;
                mListener.mController.setInsetsAndAlpha(insets, 1.0f,
                        mAnimator.getAnimatedFraction());
                mErrorCollector.checkThat(
                        "setInsetsAndAlpha() must synchronously call onProgress() but didn't",
                        mOnProgressCalled, is(true));
            });
            mAnimator.addListener(new AnimatorListenerAdapter() {
                @Override
                public void onAnimationEnd(Animator animation) {
                    if (!mListener.mController.isCancelled()) {
                        mListener.mController.finish(show);
                    }
                }
            });

            mAnimator.start();
        });
    }

    private void setVisibilityAndWait(int type, boolean visible) throws Throwable {
        assertThat("setVisibilityAndWait must only be called before any"
                + " WindowInsetsAnimation.Callback was registered", mCallbacks, equalTo(List.of()));


        final Set<WindowInsetsAnimation> runningAnimations = new HashSet<>();
        Callback callback = new Callback(Callback.DISPATCH_MODE_STOP) {

            @NonNull
            @Override
            public void onPrepare(@NonNull WindowInsetsAnimation animation) {
                synchronized (runningAnimations) {
                    runningAnimations.add(animation);
                }
            }

            @NonNull
            @Override
            public WindowInsetsAnimation.Bounds onStart(@NonNull WindowInsetsAnimation animation,
                    @NonNull WindowInsetsAnimation.Bounds bounds) {
                synchronized (runningAnimations) {
                    runningAnimations.add(animation);
                }
                return bounds;
            }

            @NonNull
            @Override
            public WindowInsets onProgress(@NonNull WindowInsets insets,
                    @NonNull List<WindowInsetsAnimation> runningAnimations) {
                return insets;
            }

            @Override
            public void onEnd(@NonNull WindowInsetsAnimation animation) {
                synchronized (runningAnimations) {
                    runningAnimations.remove(animation);
                }
            }
        };
        runOnUiThread(() -> {
            mRootView.setWindowInsetsAnimationCallback(callback);
            if (visible) {
                mRootView.getWindowInsetsController().show(type);
            } else {
                mRootView.getWindowInsetsController().hide(type);
            }
        });

        waitForOrFail("Timeout waiting for inset to become " + (visible ? "visible" : "invisible"),
                () -> mActivity.mLastWindowInsets.isVisible(mType) == visible);
        waitForOrFail("Timeout waiting for animations to end, running=" + runningAnimations,
                () -> {
                    synchronized (runningAnimations) {
                        return runningAnimations.isEmpty();
                    }
                });

        runOnUiThread(() -> {
            mRootView.setWindowInsetsAnimationCallback(null);
        });
    }

    static class ControlListener implements WindowInsetsAnimationControlListener {
        private final ErrorCollector mErrorCollector;

        WindowInsetsAnimationController mController = null;
        int mTypes = -1;
        RuntimeException mCancelledStack = null;

        ControlListener(ErrorCollector errorCollector) {
            mErrorCollector = errorCollector;
        }

        enum Event {
            READY, FINISHED, CANCELLED;
        }

        /** Latch for every callback event. */
        private CountDownLatch[] mLatches = {
                new CountDownLatch(1),
                new CountDownLatch(1),
                new CountDownLatch(1),
        };

        @Override
        public void onReady(@NonNull WindowInsetsAnimationController controller, int types) {
            mController = controller;
            mTypes = types;

            // Collect errors here and below, so we don't crash the main thread.
            mErrorCollector.checkThat(controller, notNullValue());
            mErrorCollector.checkThat(types, not(equalTo(0)));
            mErrorCollector.checkThat("isReady", controller.isReady(), is(true));
            mErrorCollector.checkThat("isFinished", controller.isFinished(), is(false));
            mErrorCollector.checkThat("isCancelled", controller.isCancelled(), is(false));
            report(READY);
        }

        @Override
        public void onFinished(@NonNull WindowInsetsAnimationController controller) {
            mErrorCollector.checkThat(controller, notNullValue());
            mErrorCollector.checkThat(controller, sameInstance(mController));
            mErrorCollector.checkThat("isReady", controller.isReady(), is(false));
            mErrorCollector.checkThat("isFinished", controller.isFinished(), is(true));
            mErrorCollector.checkThat("isCancelled", controller.isCancelled(), is(false));
            report(FINISHED);
        }

        @Override
        public void onCancelled(@Nullable WindowInsetsAnimationController controller) {
            mErrorCollector.checkThat(controller, sameInstance(mController));
            if (controller != null) {
                mErrorCollector.checkThat("isReady", controller.isReady(), is(false));
                mErrorCollector.checkThat("isFinished", controller.isFinished(), is(false));
                mErrorCollector.checkThat("isCancelled", controller.isCancelled(), is(true));
            }
            mCancelledStack = new RuntimeException("onCancelled called here");
            report(CANCELLED);
        }

        private void report(Event event) {
            CountDownLatch latch = mLatches[event.ordinal()];
            mErrorCollector.checkThat(event + ": count", latch.getCount(), is(1L));
            latch.countDown();
        }

        void awaitAndAssert(Event event) {
            CountDownLatch latch = mLatches[event.ordinal()];
            try {
                if (!latch.await(10, TimeUnit.SECONDS)) {
                    if (event == READY && mCancelledStack != null) {
                        throw new CancelledWhileWaitingForReadyException(
                                "expected " + event + " but instead got " + CANCELLED,
                                mCancelledStack);
                    }
                    fail("Timeout waiting for " + event + "; reported events: " + reportedEvents());
                }
            } catch (InterruptedException e) {
                throw new AssertionError("Interrupted", e);
            }
        }

        void assertWasCalled(Event event) {
            CountDownLatch latch = mLatches[event.ordinal()];
            assertEquals(event + " expected, but never called; called: " + reportedEvents(),
                    0, latch.getCount());
        }

        void assertWasNotCalled(Event event) {
            CountDownLatch latch = mLatches[event.ordinal()];
            assertEquals(event + " not expected, but was called; called: " + reportedEvents(),
                    1, latch.getCount());
        }

        String reportedEvents() {
            return Arrays.stream(Event.values())
                    .filter((e) -> mLatches[e.ordinal()].getCount() == 0)
                    .map(Enum::toString)
                    .collect(Collectors.joining(",", "<", ">"));
        }
    }


    private class VerifyingCallback extends Callback {
        private final Callback mInner;
        private final Set<WindowInsetsAnimation> mPreparedAnimations = new HashSet<>();
        private final Set<WindowInsetsAnimation> mRunningAnimations = new HashSet<>();
        private final Set<WindowInsetsAnimation> mEndedAnimations = new HashSet<>();

        public VerifyingCallback(Callback callback) {
            super(callback.getDispatchMode());
            mInner = callback;
        }

        @Override
        public void onPrepare(@NonNull WindowInsetsAnimation animation) {
            mErrorCollector.checkThat("onPrepare: animation", animation, notNullValue());
            mErrorCollector.checkThat("onPrepare", mPreparedAnimations, not(hasItem(animation)));
            mPreparedAnimations.add(animation);
            mInner.onPrepare(animation);
        }

        @NonNull
        @Override
        public WindowInsetsAnimation.Bounds onStart(@NonNull WindowInsetsAnimation animation,
                @NonNull WindowInsetsAnimation.Bounds bounds) {
            mErrorCollector.checkThat("onStart: animation", animation, notNullValue());
            mErrorCollector.checkThat("onStart: bounds", bounds, notNullValue());

            mErrorCollector.checkThat("onStart: mPreparedAnimations",
                    mPreparedAnimations, hasItem(animation));
            mErrorCollector.checkThat("onStart: mRunningAnimations",
                    mRunningAnimations, not(hasItem(animation)));
            mRunningAnimations.add(animation);
            mPreparedAnimations.remove(animation);
            return mInner.onStart(animation, bounds);
        }

        @NonNull
        @Override
        public WindowInsets onProgress(@NonNull WindowInsets insets,
                @NonNull List<WindowInsetsAnimation> runningAnimations) {
            mErrorCollector.checkThat("onProgress: insets", insets, notNullValue());
            mErrorCollector.checkThat("onProgress: runningAnimations",
                    runningAnimations, notNullValue());

            mErrorCollector.checkThat("onProgress", new HashSet<>(runningAnimations),
                    is(equalTo(mRunningAnimations)));
            return mInner.onProgress(insets, runningAnimations);
        }

        @Override
        public void onEnd(@NonNull WindowInsetsAnimation animation) {
            mErrorCollector.checkThat("onEnd: animation", animation, notNullValue());

            mErrorCollector.checkThat("onEnd for this animation was already dispatched",
                    mEndedAnimations, not(hasItem(animation)));
            mErrorCollector.checkThat("onEnd: animation must be either running or prepared",
                    mRunningAnimations.contains(animation)
                            || mPreparedAnimations.contains(animation),
                    is(true));
            mRunningAnimations.remove(animation);
            mPreparedAnimations.remove(animation);
            mEndedAnimations.add(animation);
            mInner.onEnd(animation);
        }

        public void assertNoPendingAnimations() {
            mErrorCollector.checkThat("Animations with onStart but missing onEnd:",
                    mRunningAnimations, equalTo(Set.of()));
            mErrorCollector.checkThat("Animations with onPrepare but missing onStart:",
                    mPreparedAnimations, equalTo(Set.of()));
        }
    }

    public static final class LimitedErrorCollector extends ErrorCollector {
        private static final int THROW_LIMIT = 1;
        private static final int LOG_LIMIT = 10;
        private static final boolean REPORT_SUPPRESSED_ERRORS_AS_THROWABLE = false;
        private int mCount = 0;
        private List<Throwable> mSuppressedErrors = new ArrayList<>();

        @Override
        public void addError(Throwable error) {
            if (mCount < THROW_LIMIT) {
                super.addError(error);
            } else if (mCount < LOG_LIMIT) {
                mSuppressedErrors.add(error);
            }
            mCount++;
        }

        @Override
        protected void verify() throws Throwable {
            if (mCount > THROW_LIMIT) {
                if (REPORT_SUPPRESSED_ERRORS_AS_THROWABLE) {
                    super.addError(
                            new AssertionError((mCount - THROW_LIMIT) + " errors suppressed."));
                } else {
                    Log.i("LimitedErrorCollector", (mCount - THROW_LIMIT) + " errors suppressed; "
                            + "additional errors:");
                    for (Throwable t : mSuppressedErrors) {
                        Log.e("LimitedErrorCollector", "", t);
                    }
                }
            }
            super.verify();
        }
    }

    private interface ThrowableThrowingRunnable {
        void run() throws Throwable;
    }

    private static class CancelledWhileWaitingForReadyException extends AssertionError {
        public CancelledWhileWaitingForReadyException(String message, Throwable cause) {
            super(message, cause);
        }
    };
}