packages/SystemUI/tests/src/com/android/systemui/bubbles/animation/PhysicsAnimationLayoutTest.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2019 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 com.android.systemui.bubbles.animation;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.ArgumentMatchers.anyFloat;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.never;

 import android.os.SystemClock;
 import android.support.test.filters.SmallTest;
 import android.testing.AndroidTestingRunner;
 import android.view.View;
 import android.widget.FrameLayout;

 import androidx.dynamicanimation.animation.DynamicAnimation;
 import androidx.dynamicanimation.animation.SpringForce;

 import com.google.android.collect.Sets;

 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InOrder;
 import org.mockito.Mockito;
 import org.mockito.Spy;

 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;

 @SmallTest
 @RunWith(AndroidTestingRunner.class)
 /** Tests the PhysicsAnimationLayout itself, with a basic test animation controller. */
 public class PhysicsAnimationLayoutTest extends PhysicsAnimationLayoutTestCase {
     static final float TEST_TRANSLATION_X_OFFSET = 15f;

     @Spy
     private TestableAnimationController mTestableController = new TestableAnimationController();

     @Before
     public void setUp() throws Exception {
         super.setUp();

         // By default, use translation animations, chain the X animations with the default
         // offset, and don't actually remove views immediately (since most implementations will wait
         // to animate child views out before actually removing them).
         mTestableController.setAnimatedProperties(Sets.newHashSet(
                 DynamicAnimation.TRANSLATION_X, DynamicAnimation.TRANSLATION_Y));
         mTestableController.setChainedProperties(Sets.newHashSet(DynamicAnimation.TRANSLATION_X));
         mTestableController.setOffsetForProperty(
                 DynamicAnimation.TRANSLATION_X, TEST_TRANSLATION_X_OFFSET);
         mTestableController.setRemoveImmediately(false);
     }

     @Test
     public void testRenderVisibility() throws InterruptedException {
         mLayout.setController(mTestableController);
         addOneMoreThanRenderLimitBubbles();

         // The last child should be GONE, the rest VISIBLE.
         for (int i = 0; i < mMaxRenderedBubbles + 1; i++) {
             assertEquals(i == mMaxRenderedBubbles ? View.GONE : View.VISIBLE,
                     mLayout.getChildAt(i).getVisibility());
         }
     }

     @Test
     public void testHierarchyChanges() throws InterruptedException {
         mLayout.setController(mTestableController);
         addOneMoreThanRenderLimitBubbles();

         // Make sure the controller was notified of all the views we added.
         for (View mView : mViews) {
             Mockito.verify(mTestableController).onChildAdded(mView, 0);
         }

         // Remove some views and ensure the controller was notified, with the proper indices.
         mTestableController.setRemoveImmediately(true);
         mLayout.removeView(mViews.get(1));
         mLayout.removeView(mViews.get(2));
         Mockito.verify(mTestableController).onChildRemoved(
                 eq(mViews.get(1)), eq(1), any());
         Mockito.verify(mTestableController).onChildRemoved(
                 eq(mViews.get(2)), eq(1), any());

         // Make sure we still get view added notifications after doing some removals.
         final View newBubble = new FrameLayout(mContext);
         mLayout.addView(newBubble, 0);
         Mockito.verify(mTestableController).onChildAdded(newBubble, 0);
     }

     @Test
     public void testUpdateValueNotChained() throws InterruptedException {
         mLayout.setController(mTestableController);
         addOneMoreThanRenderLimitBubbles();

         // Don't chain any values.
         mTestableController.setChainedProperties(Sets.newHashSet());

         // Child views should not be translated.
         assertEquals(0, mLayout.getChildAt(0).getTranslationX(), .1f);
         assertEquals(0, mLayout.getChildAt(1).getTranslationX(), .1f);

         // Animate the first child's translation X.
         final CountDownLatch animLatch = new CountDownLatch(1);
         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.TRANSLATION_X,
                 0,
                 100,
                 animLatch::countDown);
         animLatch.await(1, TimeUnit.SECONDS);

         // Ensure that the first view has been translated, but not the second one.
         assertEquals(100, mLayout.getChildAt(0).getTranslationX(), .1f);
         assertEquals(0, mLayout.getChildAt(1).getTranslationX(), .1f);
     }

     @Test
     public void testUpdateValueXChained() throws InterruptedException {
         mLayout.setController(mTestableController);
         addOneMoreThanRenderLimitBubbles();
         testChainedTranslationAnimations();
     }

     @Test
     public void testSetEndListeners() throws InterruptedException {
         mLayout.setController(mTestableController);
         addOneMoreThanRenderLimitBubbles();
         mTestableController.setChainedProperties(Sets.newHashSet());

         final CountDownLatch xLatch = new CountDownLatch(1);
         OneTimeEndListener xEndListener = Mockito.spy(new OneTimeEndListener() {
             @Override
             public void onAnimationEnd(DynamicAnimation animation, boolean canceled, float value,
                     float velocity) {
                 super.onAnimationEnd(animation, canceled, value, velocity);
                 xLatch.countDown();
             }
         });

         final CountDownLatch yLatch = new CountDownLatch(1);
         final OneTimeEndListener yEndListener = Mockito.spy(new OneTimeEndListener() {
             @Override
             public void onAnimationEnd(DynamicAnimation animation, boolean canceled, float value,
                     float velocity) {
                 super.onAnimationEnd(animation, canceled, value, velocity);
                 yLatch.countDown();
             }
         });

         // Set end listeners for both x and y.
         mLayout.setEndListenerForProperty(xEndListener, DynamicAnimation.TRANSLATION_X);
         mLayout.setEndListenerForProperty(yEndListener, DynamicAnimation.TRANSLATION_Y);

         // Animate x, and wait for it to finish.
         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.TRANSLATION_X,
                 0,
                 100);
         xLatch.await();
         yLatch.await(1, TimeUnit.SECONDS);

         // Make sure the x end listener was called only one time, and the y listener was never
         // called since we didn't animate y. Wait 1 second after the original animation end trigger
         // to make sure it doesn't get called again.
         Mockito.verify(xEndListener, Mockito.after(1000).times(1))
                 .onAnimationEnd(
                         any(),
                         eq(false),
                         eq(100f),
                         anyFloat());
         Mockito.verify(yEndListener, Mockito.after(1000).never())
                 .onAnimationEnd(any(), anyBoolean(), anyFloat(), anyFloat());
     }

     @Test
     public void testRemoveEndListeners() throws InterruptedException {
         mLayout.setController(mTestableController);
         addOneMoreThanRenderLimitBubbles();
         mTestableController.setChainedProperties(Sets.newHashSet());

         final CountDownLatch xLatch = new CountDownLatch(1);
         OneTimeEndListener xEndListener = Mockito.spy(new OneTimeEndListener() {
             @Override
             public void onAnimationEnd(DynamicAnimation animation, boolean canceled, float value,
                     float velocity) {
                 super.onAnimationEnd(animation, canceled, value, velocity);
                 xLatch.countDown();
             }
         });

         // Set the end listener.
         mLayout.setEndListenerForProperty(xEndListener, DynamicAnimation.TRANSLATION_X);

         // Animate x, and wait for it to finish.
         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.TRANSLATION_X,
                 0,
                 100);
         xLatch.await();

         InOrder endListenerCalls = inOrder(xEndListener);
         endListenerCalls.verify(xEndListener, Mockito.times(1))
                 .onAnimationEnd(
                         any(),
                         eq(false),
                         eq(100f),
                         anyFloat());

         // Animate X again, remove the end listener.
         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.TRANSLATION_X,
                 0,
                 1000);
         mLayout.removeEndListenerForProperty(DynamicAnimation.TRANSLATION_X);
         xLatch.await(1, TimeUnit.SECONDS);

         // Make sure the end listener was not called.
         endListenerCalls.verifyNoMoreInteractions();
     }

     @Test
     public void testSetController() throws InterruptedException {
         // Add the bubbles, then set the controller, to make sure that a controller added to an
         // already-initialized view works correctly.
         addOneMoreThanRenderLimitBubbles();
         mLayout.setController(mTestableController);
         testChainedTranslationAnimations();

         TestableAnimationController secondController =
                 Mockito.spy(new TestableAnimationController());
         secondController.setAnimatedProperties(Sets.newHashSet(
                 DynamicAnimation.SCALE_X, DynamicAnimation.SCALE_Y));
         secondController.setChainedProperties(Sets.newHashSet(
                 DynamicAnimation.SCALE_X));
         secondController.setOffsetForProperty(
                 DynamicAnimation.SCALE_X, 10f);
         secondController.setRemoveImmediately(true);

         mLayout.setController(secondController);
         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.SCALE_X,
                 0,
                 1.5f);

         waitForPropertyAnimations(DynamicAnimation.SCALE_X);

         // Make sure we never asked the original controller about any SCALE animations, that would
         // mean the controller wasn't switched over properly.
         Mockito.verify(mTestableController, Mockito.never())
                 .getNextAnimationInChain(eq(DynamicAnimation.SCALE_X), anyInt());
         Mockito.verify(mTestableController, Mockito.never())
                 .getOffsetForChainedPropertyAnimation(eq(DynamicAnimation.SCALE_X));

         // Make sure we asked the new controller about its animated properties, and configuration
         // options.
         Mockito.verify(secondController, Mockito.atLeastOnce())
                 .getAnimatedProperties();
         Mockito.verify(secondController, Mockito.atLeastOnce())
                 .getNextAnimationInChain(eq(DynamicAnimation.SCALE_X), anyInt());
         Mockito.verify(secondController, Mockito.atLeastOnce())
                 .getOffsetForChainedPropertyAnimation(eq(DynamicAnimation.SCALE_X));

         mLayout.setController(mTestableController);
         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.TRANSLATION_X,
                 0,
                 100f);

         waitForPropertyAnimations(DynamicAnimation.TRANSLATION_X);

         // Make sure we never asked the second controller about the TRANSLATION_X animation.
         Mockito.verify(secondController, Mockito.never())
                 .getNextAnimationInChain(eq(DynamicAnimation.TRANSLATION_X), anyInt());
         Mockito.verify(secondController, Mockito.never())
                 .getOffsetForChainedPropertyAnimation(eq(DynamicAnimation.TRANSLATION_X));

     }

     @Test
     public void testArePropertiesAnimating() throws InterruptedException {
         mLayout.setController(mTestableController);
         addOneMoreThanRenderLimitBubbles();

         assertFalse(mLayout.arePropertiesAnimating(
                 DynamicAnimation.TRANSLATION_X, DynamicAnimation.TRANSLATION_Y));

         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.TRANSLATION_X,
                 0,
                 100);

         // Wait for the animations to get underway.
         SystemClock.sleep(50);

         assertTrue(mLayout.arePropertiesAnimating(DynamicAnimation.TRANSLATION_X));
         assertFalse(mLayout.arePropertiesAnimating(DynamicAnimation.TRANSLATION_Y));

         waitForPropertyAnimations(DynamicAnimation.TRANSLATION_X);

         assertFalse(mLayout.arePropertiesAnimating(
                 DynamicAnimation.TRANSLATION_X, DynamicAnimation.TRANSLATION_Y));
     }

     @Test
     public void testCancelAllAnimations() throws InterruptedException {
         mLayout.setController(mTestableController);
         addOneMoreThanRenderLimitBubbles();

         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.TRANSLATION_X,
                 0,
                 1000);
         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.TRANSLATION_Y,
                 0,
                 1000);

         mLayout.cancelAllAnimations();

         // Animations should be somewhere before their end point.
         assertTrue(mViews.get(0).getTranslationX() < 1000);
         assertTrue(mViews.get(0).getTranslationY() < 1000);
     }

     @Test
     public void testSetChildVisibility() throws InterruptedException {
         mLayout.setController(mTestableController);
         addOneMoreThanRenderLimitBubbles();

         // The last view should have been set to GONE by the controller, since we added one more
         // than the limit and it got pushed off. None of the first children should have been set
         // VISIBLE, since they would have been animated in by onChildAdded.
         Mockito.verify(mTestableController).setChildVisibility(
                 mViews.get(mViews.size() - 1), 5, View.GONE);
         Mockito.verify(mTestableController, never()).setChildVisibility(
                 any(View.class), anyInt(), eq(View.VISIBLE));

         // Remove the first view, which should cause the last view to become visible again.
         mLayout.removeView(mViews.get(0));
         Mockito.verify(mTestableController).setChildVisibility(
                 mViews.get(mViews.size() - 1), 4, View.VISIBLE);
     }

     /** Standard test of chained translation animations. */
     private void testChainedTranslationAnimations() throws InterruptedException {
         assertEquals(0, mLayout.getChildAt(0).getTranslationX(), .1f);
         assertEquals(0, mLayout.getChildAt(1).getTranslationX(), .1f);

         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.TRANSLATION_X,
                 0,
                 100);

         waitForPropertyAnimations(DynamicAnimation.TRANSLATION_X);

         // Since we enabled chaining, animating the first view to 100 should animate the second to
         // 115 (since we set the offset to 15) and the third to 130, etc. Despite the sixth bubble
         // not being visible, or animated, make sure that it has the appropriate chained
         // translation.
         for (int i = 0; i < mMaxRenderedBubbles + 1; i++) {
             assertEquals(
                     100 + i * TEST_TRANSLATION_X_OFFSET,
                     mLayout.getChildAt(i).getTranslationX(), .1f);
         }

         // Ensure that the Y translations were unaffected.
         assertEquals(0, mLayout.getChildAt(0).getTranslationY(), .1f);
         assertEquals(0, mLayout.getChildAt(1).getTranslationY(), .1f);

         // Animate the first child's Y translation.
         mLayout.animateValueForChildAtIndex(
                 DynamicAnimation.TRANSLATION_Y,
                 0,
                 100);

         waitForPropertyAnimations(DynamicAnimation.TRANSLATION_Y);

         // Ensure that only the first view's Y translation chained, since we only chained X
         // translations.
         assertEquals(100, mLayout.getChildAt(0).getTranslationY(), .1f);
         assertEquals(0, mLayout.getChildAt(1).getTranslationY(), .1f);
     }

     /**
      * Animation controller with configuration methods whose return values can be set by individual
      * tests.
      */
     private class TestableAnimationController
             extends PhysicsAnimationLayout.PhysicsAnimationController {
         private Set<DynamicAnimation.ViewProperty> mAnimatedProperties = new HashSet<>();
         private Set<DynamicAnimation.ViewProperty> mChainedProperties = new HashSet<>();
         private HashMap<DynamicAnimation.ViewProperty, Float> mOffsetForProperty = new HashMap<>();
         private boolean mRemoveImmediately = false;

         void setAnimatedProperties(
                 Set<DynamicAnimation.ViewProperty> animatedProperties) {
             mAnimatedProperties = animatedProperties;
         }

         void setChainedProperties(
                 Set<DynamicAnimation.ViewProperty> chainedProperties) {
             mChainedProperties = chainedProperties;
         }

         void setOffsetForProperty(
                 DynamicAnimation.ViewProperty property, float offset) {
             mOffsetForProperty.put(property, offset);
         }

         public void setRemoveImmediately(boolean removeImmediately) {
             mRemoveImmediately = removeImmediately;
         }

         @Override
         Set<DynamicAnimation.ViewProperty> getAnimatedProperties() {
             return mAnimatedProperties;
         }

         @Override
         int getNextAnimationInChain(DynamicAnimation.ViewProperty property, int index) {
             return mChainedProperties.contains(property) ? index + 1 : NONE;
         }

         @Override
         float getOffsetForChainedPropertyAnimation(DynamicAnimation.ViewProperty property) {
             return mOffsetForProperty.getOrDefault(property, 0f);
         }

         @Override
         SpringForce getSpringForce(DynamicAnimation.ViewProperty property, View view) {
             return new SpringForce();
         }

         @Override
         void onChildAdded(View child, int index) {}

         @Override
         void onChildRemoved(View child, int index, Runnable finishRemoval) {
             if (mRemoveImmediately) {
                 finishRemoval.run();
             }
         }

         @Override
         protected void setChildVisibility(View child, int index, int visibility) {
             super.setChildVisibility(child, index, visibility);
         }
     }
 }
	/*
	* Copyright (C) 2019 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 com.android.systemui.bubbles.animation;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertTrue;
	import static org.mockito.ArgumentMatchers.any;
	import static org.mockito.ArgumentMatchers.anyBoolean;
	import static org.mockito.ArgumentMatchers.anyFloat;
	import static org.mockito.ArgumentMatchers.anyInt;
	import static org.mockito.ArgumentMatchers.eq;
	import static org.mockito.Mockito.inOrder;
	import static org.mockito.Mockito.never;

	import android.os.SystemClock;
	import android.support.test.filters.SmallTest;
	import android.testing.AndroidTestingRunner;
	import android.view.View;
	import android.widget.FrameLayout;

	import androidx.dynamicanimation.animation.DynamicAnimation;
	import androidx.dynamicanimation.animation.SpringForce;

	import com.google.android.collect.Sets;

	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.mockito.InOrder;
	import org.mockito.Mockito;
	import org.mockito.Spy;

	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Set;
	import java.util.concurrent.CountDownLatch;
	import java.util.concurrent.TimeUnit;

	@SmallTest
	@RunWith(AndroidTestingRunner.class)
	/** Tests the PhysicsAnimationLayout itself, with a basic test animation controller. */
	public class PhysicsAnimationLayoutTest extends PhysicsAnimationLayoutTestCase {
	static final float TEST_TRANSLATION_X_OFFSET = 15f;

	@Spy
	private TestableAnimationController mTestableController = new TestableAnimationController();

	@Before
	public void setUp() throws Exception {
	super.setUp();

	// By default, use translation animations, chain the X animations with the default
	// offset, and don't actually remove views immediately (since most implementations will wait
	// to animate child views out before actually removing them).
	mTestableController.setAnimatedProperties(Sets.newHashSet(
	DynamicAnimation.TRANSLATION_X, DynamicAnimation.TRANSLATION_Y));
	mTestableController.setChainedProperties(Sets.newHashSet(DynamicAnimation.TRANSLATION_X));
	mTestableController.setOffsetForProperty(
	DynamicAnimation.TRANSLATION_X, TEST_TRANSLATION_X_OFFSET);
	mTestableController.setRemoveImmediately(false);
	}

	@Test
	public void testRenderVisibility() throws InterruptedException {
	mLayout.setController(mTestableController);
	addOneMoreThanRenderLimitBubbles();

	// The last child should be GONE, the rest VISIBLE.
	for (int i = 0; i < mMaxRenderedBubbles + 1; i++) {
	assertEquals(i == mMaxRenderedBubbles ? View.GONE : View.VISIBLE,
	mLayout.getChildAt(i).getVisibility());
	}
	}

	@Test
	public void testHierarchyChanges() throws InterruptedException {
	mLayout.setController(mTestableController);
	addOneMoreThanRenderLimitBubbles();

	// Make sure the controller was notified of all the views we added.
	for (View mView : mViews) {
	Mockito.verify(mTestableController).onChildAdded(mView, 0);
	}

	// Remove some views and ensure the controller was notified, with the proper indices.
	mTestableController.setRemoveImmediately(true);
	mLayout.removeView(mViews.get(1));
	mLayout.removeView(mViews.get(2));
	Mockito.verify(mTestableController).onChildRemoved(
	eq(mViews.get(1)), eq(1), any());
	Mockito.verify(mTestableController).onChildRemoved(
	eq(mViews.get(2)), eq(1), any());

	// Make sure we still get view added notifications after doing some removals.
	final View newBubble = new FrameLayout(mContext);
	mLayout.addView(newBubble, 0);
	Mockito.verify(mTestableController).onChildAdded(newBubble, 0);
	}

	@Test
	public void testUpdateValueNotChained() throws InterruptedException {
	mLayout.setController(mTestableController);
	addOneMoreThanRenderLimitBubbles();

	// Don't chain any values.
	mTestableController.setChainedProperties(Sets.newHashSet());

	// Child views should not be translated.
	assertEquals(0, mLayout.getChildAt(0).getTranslationX(), .1f);
	assertEquals(0, mLayout.getChildAt(1).getTranslationX(), .1f);

	// Animate the first child's translation X.
	final CountDownLatch animLatch = new CountDownLatch(1);
	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.TRANSLATION_X,
	0,
	100,
	animLatch::countDown);
	animLatch.await(1, TimeUnit.SECONDS);

	// Ensure that the first view has been translated, but not the second one.
	assertEquals(100, mLayout.getChildAt(0).getTranslationX(), .1f);
	assertEquals(0, mLayout.getChildAt(1).getTranslationX(), .1f);
	}

	@Test
	public void testUpdateValueXChained() throws InterruptedException {
	mLayout.setController(mTestableController);
	addOneMoreThanRenderLimitBubbles();
	testChainedTranslationAnimations();
	}

	@Test
	public void testSetEndListeners() throws InterruptedException {
	mLayout.setController(mTestableController);
	addOneMoreThanRenderLimitBubbles();
	mTestableController.setChainedProperties(Sets.newHashSet());

	final CountDownLatch xLatch = new CountDownLatch(1);
	OneTimeEndListener xEndListener = Mockito.spy(new OneTimeEndListener() {
	@Override
	public void onAnimationEnd(DynamicAnimation animation, boolean canceled, float value,
	float velocity) {
	super.onAnimationEnd(animation, canceled, value, velocity);
	xLatch.countDown();
	}
	});

	final CountDownLatch yLatch = new CountDownLatch(1);
	final OneTimeEndListener yEndListener = Mockito.spy(new OneTimeEndListener() {
	@Override
	public void onAnimationEnd(DynamicAnimation animation, boolean canceled, float value,
	float velocity) {
	super.onAnimationEnd(animation, canceled, value, velocity);
	yLatch.countDown();
	}
	});

	// Set end listeners for both x and y.
	mLayout.setEndListenerForProperty(xEndListener, DynamicAnimation.TRANSLATION_X);
	mLayout.setEndListenerForProperty(yEndListener, DynamicAnimation.TRANSLATION_Y);

	// Animate x, and wait for it to finish.
	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.TRANSLATION_X,
	0,
	100);
	xLatch.await();
	yLatch.await(1, TimeUnit.SECONDS);

	// Make sure the x end listener was called only one time, and the y listener was never
	// called since we didn't animate y. Wait 1 second after the original animation end trigger
	// to make sure it doesn't get called again.
	Mockito.verify(xEndListener, Mockito.after(1000).times(1))
	.onAnimationEnd(
	any(),
	eq(false),
	eq(100f),
	anyFloat());
	Mockito.verify(yEndListener, Mockito.after(1000).never())
	.onAnimationEnd(any(), anyBoolean(), anyFloat(), anyFloat());
	}

	@Test
	public void testRemoveEndListeners() throws InterruptedException {
	mLayout.setController(mTestableController);
	addOneMoreThanRenderLimitBubbles();
	mTestableController.setChainedProperties(Sets.newHashSet());

	final CountDownLatch xLatch = new CountDownLatch(1);
	OneTimeEndListener xEndListener = Mockito.spy(new OneTimeEndListener() {
	@Override
	public void onAnimationEnd(DynamicAnimation animation, boolean canceled, float value,
	float velocity) {
	super.onAnimationEnd(animation, canceled, value, velocity);
	xLatch.countDown();
	}
	});

	// Set the end listener.
	mLayout.setEndListenerForProperty(xEndListener, DynamicAnimation.TRANSLATION_X);

	// Animate x, and wait for it to finish.
	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.TRANSLATION_X,
	0,
	100);
	xLatch.await();

	InOrder endListenerCalls = inOrder(xEndListener);
	endListenerCalls.verify(xEndListener, Mockito.times(1))
	.onAnimationEnd(
	any(),
	eq(false),
	eq(100f),
	anyFloat());

	// Animate X again, remove the end listener.
	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.TRANSLATION_X,
	0,
	1000);
	mLayout.removeEndListenerForProperty(DynamicAnimation.TRANSLATION_X);
	xLatch.await(1, TimeUnit.SECONDS);

	// Make sure the end listener was not called.
	endListenerCalls.verifyNoMoreInteractions();
	}

	@Test
	public void testSetController() throws InterruptedException {
	// Add the bubbles, then set the controller, to make sure that a controller added to an
	// already-initialized view works correctly.
	addOneMoreThanRenderLimitBubbles();
	mLayout.setController(mTestableController);
	testChainedTranslationAnimations();

	TestableAnimationController secondController =
	Mockito.spy(new TestableAnimationController());
	secondController.setAnimatedProperties(Sets.newHashSet(
	DynamicAnimation.SCALE_X, DynamicAnimation.SCALE_Y));
	secondController.setChainedProperties(Sets.newHashSet(
	DynamicAnimation.SCALE_X));
	secondController.setOffsetForProperty(
	DynamicAnimation.SCALE_X, 10f);
	secondController.setRemoveImmediately(true);

	mLayout.setController(secondController);
	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.SCALE_X,
	0,
	1.5f);

	waitForPropertyAnimations(DynamicAnimation.SCALE_X);

	// Make sure we never asked the original controller about any SCALE animations, that would
	// mean the controller wasn't switched over properly.
	Mockito.verify(mTestableController, Mockito.never())
	.getNextAnimationInChain(eq(DynamicAnimation.SCALE_X), anyInt());
	Mockito.verify(mTestableController, Mockito.never())
	.getOffsetForChainedPropertyAnimation(eq(DynamicAnimation.SCALE_X));

	// Make sure we asked the new controller about its animated properties, and configuration
	// options.
	Mockito.verify(secondController, Mockito.atLeastOnce())
	.getAnimatedProperties();
	Mockito.verify(secondController, Mockito.atLeastOnce())
	.getNextAnimationInChain(eq(DynamicAnimation.SCALE_X), anyInt());
	Mockito.verify(secondController, Mockito.atLeastOnce())
	.getOffsetForChainedPropertyAnimation(eq(DynamicAnimation.SCALE_X));

	mLayout.setController(mTestableController);
	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.TRANSLATION_X,
	0,
	100f);

	waitForPropertyAnimations(DynamicAnimation.TRANSLATION_X);

	// Make sure we never asked the second controller about the TRANSLATION_X animation.
	Mockito.verify(secondController, Mockito.never())
	.getNextAnimationInChain(eq(DynamicAnimation.TRANSLATION_X), anyInt());
	Mockito.verify(secondController, Mockito.never())
	.getOffsetForChainedPropertyAnimation(eq(DynamicAnimation.TRANSLATION_X));

	}

	@Test
	public void testArePropertiesAnimating() throws InterruptedException {
	mLayout.setController(mTestableController);
	addOneMoreThanRenderLimitBubbles();

	assertFalse(mLayout.arePropertiesAnimating(
	DynamicAnimation.TRANSLATION_X, DynamicAnimation.TRANSLATION_Y));

	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.TRANSLATION_X,
	0,
	100);

	// Wait for the animations to get underway.
	SystemClock.sleep(50);

	assertTrue(mLayout.arePropertiesAnimating(DynamicAnimation.TRANSLATION_X));
	assertFalse(mLayout.arePropertiesAnimating(DynamicAnimation.TRANSLATION_Y));

	waitForPropertyAnimations(DynamicAnimation.TRANSLATION_X);

	assertFalse(mLayout.arePropertiesAnimating(
	DynamicAnimation.TRANSLATION_X, DynamicAnimation.TRANSLATION_Y));
	}

	@Test
	public void testCancelAllAnimations() throws InterruptedException {
	mLayout.setController(mTestableController);
	addOneMoreThanRenderLimitBubbles();

	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.TRANSLATION_X,
	0,
	1000);
	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.TRANSLATION_Y,
	0,
	1000);

	mLayout.cancelAllAnimations();

	// Animations should be somewhere before their end point.
	assertTrue(mViews.get(0).getTranslationX() < 1000);
	assertTrue(mViews.get(0).getTranslationY() < 1000);
	}

	@Test
	public void testSetChildVisibility() throws InterruptedException {
	mLayout.setController(mTestableController);
	addOneMoreThanRenderLimitBubbles();

	// The last view should have been set to GONE by the controller, since we added one more
	// than the limit and it got pushed off. None of the first children should have been set
	// VISIBLE, since they would have been animated in by onChildAdded.
	Mockito.verify(mTestableController).setChildVisibility(
	mViews.get(mViews.size() - 1), 5, View.GONE);
	Mockito.verify(mTestableController, never()).setChildVisibility(
	any(View.class), anyInt(), eq(View.VISIBLE));

	// Remove the first view, which should cause the last view to become visible again.
	mLayout.removeView(mViews.get(0));
	Mockito.verify(mTestableController).setChildVisibility(
	mViews.get(mViews.size() - 1), 4, View.VISIBLE);
	}

	/** Standard test of chained translation animations. */
	private void testChainedTranslationAnimations() throws InterruptedException {
	assertEquals(0, mLayout.getChildAt(0).getTranslationX(), .1f);
	assertEquals(0, mLayout.getChildAt(1).getTranslationX(), .1f);

	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.TRANSLATION_X,
	0,
	100);

	waitForPropertyAnimations(DynamicAnimation.TRANSLATION_X);

	// Since we enabled chaining, animating the first view to 100 should animate the second to
	// 115 (since we set the offset to 15) and the third to 130, etc. Despite the sixth bubble
	// not being visible, or animated, make sure that it has the appropriate chained
	// translation.
	for (int i = 0; i < mMaxRenderedBubbles + 1; i++) {
	assertEquals(
	100 + i * TEST_TRANSLATION_X_OFFSET,
	mLayout.getChildAt(i).getTranslationX(), .1f);
	}

	// Ensure that the Y translations were unaffected.
	assertEquals(0, mLayout.getChildAt(0).getTranslationY(), .1f);
	assertEquals(0, mLayout.getChildAt(1).getTranslationY(), .1f);

	// Animate the first child's Y translation.
	mLayout.animateValueForChildAtIndex(
	DynamicAnimation.TRANSLATION_Y,
	0,
	100);

	waitForPropertyAnimations(DynamicAnimation.TRANSLATION_Y);

	// Ensure that only the first view's Y translation chained, since we only chained X
	// translations.
	assertEquals(100, mLayout.getChildAt(0).getTranslationY(), .1f);
	assertEquals(0, mLayout.getChildAt(1).getTranslationY(), .1f);
	}

	/**
	* Animation controller with configuration methods whose return values can be set by individual
	* tests.
	*/
	private class TestableAnimationController
	extends PhysicsAnimationLayout.PhysicsAnimationController {
	private Set<DynamicAnimation.ViewProperty> mAnimatedProperties = new HashSet<>();
	private Set<DynamicAnimation.ViewProperty> mChainedProperties = new HashSet<>();
	private HashMap<DynamicAnimation.ViewProperty, Float> mOffsetForProperty = new HashMap<>();
	private boolean mRemoveImmediately = false;

	void setAnimatedProperties(
	Set<DynamicAnimation.ViewProperty> animatedProperties) {
	mAnimatedProperties = animatedProperties;
	}

	void setChainedProperties(
	Set<DynamicAnimation.ViewProperty> chainedProperties) {
	mChainedProperties = chainedProperties;
	}

	void setOffsetForProperty(
	DynamicAnimation.ViewProperty property, float offset) {
	mOffsetForProperty.put(property, offset);
	}

	public void setRemoveImmediately(boolean removeImmediately) {
	mRemoveImmediately = removeImmediately;
	}

	@Override
	Set<DynamicAnimation.ViewProperty> getAnimatedProperties() {
	return mAnimatedProperties;
	}

	@Override
	int getNextAnimationInChain(DynamicAnimation.ViewProperty property, int index) {
	return mChainedProperties.contains(property) ? index + 1 : NONE;
	}

	@Override
	float getOffsetForChainedPropertyAnimation(DynamicAnimation.ViewProperty property) {
	return mOffsetForProperty.getOrDefault(property, 0f);
	}

	@Override
	SpringForce getSpringForce(DynamicAnimation.ViewProperty property, View view) {
	return new SpringForce();
	}

	@Override
	void onChildAdded(View child, int index) {}

	@Override
	void onChildRemoved(View child, int index, Runnable finishRemoval) {
	if (mRemoveImmediately) {
	finishRemoval.run();
	}
	}

	@Override
	protected void setChildVisibility(View child, int index, int visibility) {
	super.setChildVisibility(child, index, visibility);
	}
	}
	}