tests/tests/graphics/src/android/graphics/drawable/cts/AnimatedVectorDrawableParameterizedTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2016 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.graphics.drawable.cts;

 import static junit.framework.TestCase.assertTrue;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;

 import android.app.Activity;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Rect;
 import android.graphics.cts.R;
 import android.graphics.drawable.AnimatedVectorDrawable;
 import android.util.Log;
 import android.view.PixelCopy;
 import android.view.View;
 import android.widget.ImageView;

 import androidx.test.InstrumentationRegistry;
 import androidx.test.filters.LargeTest;
 import androidx.test.filters.MediumTest;
 import androidx.test.filters.SmallTest;
 import androidx.test.rule.ActivityTestRule;

 import com.android.compatibility.common.util.SynchronousPixelCopy;
 import com.android.compatibility.common.util.SystemUtil;
 import com.android.compatibility.common.util.WidgetTestUtils;

 import org.junit.AfterClass;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;

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

 @LargeTest
 @RunWith(Parameterized.class)
 public class AnimatedVectorDrawableParameterizedTest {
     @Rule
     public ActivityTestRule<DrawableStubActivity> mActivityRule =
             new ActivityTestRule<>(DrawableStubActivity.class);

     private static final int IMAGE_WIDTH = 64;
     private static final int IMAGE_HEIGHT = 64;
     private static final long MAX_TIMEOUT_MS = 1000;

     private static float sTransitionScaleBefore = Float.NaN;

     private Activity mActivity = null;
     private Resources mResources = null;
     private final int mLayerType;

     @Parameterized.Parameters
     public static Object[] data() {
         return new Object[] {
                 View.LAYER_TYPE_HARDWARE,
                 View.LAYER_TYPE_NONE,
                 View.LAYER_TYPE_SOFTWARE
         };
     }

     @BeforeClass
     public static void setUpClass() throws Exception {
         try {
             sTransitionScaleBefore = Float.parseFloat(SystemUtil.runShellCommand(
                     InstrumentationRegistry.getInstrumentation(),
                     "settings get global transition_animation_scale"));

             SystemUtil.runShellCommand(InstrumentationRegistry.getInstrumentation(),
                     "settings put global transition_animation_scale 0");
         } catch (NumberFormatException e) {
             Log.e("AnimatedVectorDrawableTest", "Could not read transition_animation_scale", e);
             sTransitionScaleBefore = Float.NaN;
         }
     }

     @AfterClass
     public static void tearDownClass() throws Exception {
         if (!Float.isNaN(sTransitionScaleBefore)) {
             SystemUtil.runShellCommand(InstrumentationRegistry.getInstrumentation(),
                     "settings put global transition_animation_scale " +
                             sTransitionScaleBefore);
         }
     }

     public AnimatedVectorDrawableParameterizedTest(final int layerType) throws Throwable {
         mLayerType = layerType;
     }

     @Before
     public void setup() {
         mActivity = mActivityRule.getActivity();
         mResources = mActivity.getResources();
     }

     @Test
     public void testAnimationOnLayer() throws Throwable {
         final Animatable2Callback callback = new Animatable2Callback();
         // Can't simply use final here, b/c it needs to be initialized and referred later in UI
         // thread.
         final ImageView[] imageView = new ImageView[1];
         mActivityRule.runOnUiThread(() -> {
             mActivity.setContentView(R.layout.fixed_sized_imageview);
             imageView[0] = (ImageView) mActivity.findViewById(R.id.imageview);
         });
         WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, imageView[0],
                 (Runnable) () -> {
                     imageView[0].setImageDrawable(
                             mResources.getDrawable(R.drawable.animated_vector_favorite));
                     imageView[0].setLayerType(mLayerType, null);
                     AnimatedVectorDrawable avd =
                             (AnimatedVectorDrawable) imageView[0].getDrawable();
                     avd.registerAnimationCallback(callback);
                     avd.start();
                 });
         callback.waitForStart();
         waitWhilePumpingFrames(5, imageView[0], 200);

         Bitmap lastScreenShot = null;
         final Rect srcRect = new Rect();
         mActivityRule.runOnUiThread(() -> {
             imageView[0].getGlobalVisibleRect(srcRect);
         });

         int counter = 0;
         while (!callback.endIsCalled()) {
             // Take a screen shot every 50ms, and compare with previous screenshot for the ImageView
             // content, to make sure the AVD is animating when set on HW layer.
             Bitmap screenShot = takeScreenshot(srcRect);
             if (callback.endIsCalled()) {
                 // Animation already ended, the screenshot may not contain valid animation content,
                 // skip the comparison.
                 break;
             }
             counter++;
             boolean isIdentical = isAlmostIdenticalInRect(screenShot, lastScreenShot);
             if (isIdentical) {
                 String outputFolder = mActivity.getExternalFilesDir(null).getAbsolutePath();
                 DrawableTestUtils.saveVectorDrawableIntoPNG(screenShot, outputFolder,
                         "screenshot_" + counter);
                 DrawableTestUtils.saveVectorDrawableIntoPNG(lastScreenShot, outputFolder,
                         "screenshot_" + (counter - 1));
                 fail("Two consecutive screenshots of AVD are identical, AVD is "
                         + "likely not animating");
             }
             lastScreenShot = screenShot;

             // Wait 50ms before the next screen shot. If animation ended during the wait, exit the
             // loop.
             if (callback.waitForEnd(50)) {
                 break;
             }
         }
         // In this test, we want to make sure that we at least have 5 screenshots.
         assertTrue(counter >= 5);

         mActivityRule.runOnUiThread(() -> {
             AnimatedVectorDrawable avd = (AnimatedVectorDrawable) imageView[0].getDrawable();
             avd.stop();
         });
     }

     // Pump frames by repeatedly invalidating the given view. Return true if successfully pumped
     // the given number of frames before timeout, false otherwise.
     private boolean waitWhilePumpingFrames(int frameCount, final View view, long timeout)
             throws Throwable {
         final CountDownLatch frameLatch = new CountDownLatch(frameCount);
         mActivityRule.runOnUiThread(() -> {
             view.getViewTreeObserver().addOnPreDrawListener(() -> {
                 if (frameLatch.getCount() > 0) {
                     frameLatch.countDown();
                     view.postInvalidate();
                 }
                 return true;
             });
         });
         return frameLatch.await(timeout, TimeUnit.MILLISECONDS);
     }

     @SmallTest
     @Test
     public void testSingleFrameAnimation() throws Throwable {
         int resId = R.drawable.avd_single_frame;
         final AnimatedVectorDrawable d1 =
                 (AnimatedVectorDrawable) mResources.getDrawable(resId);
         // The AVD has a duration as 16ms.
         mActivityRule.runOnUiThread(() -> {
             Bitmap bitmap =
                     Bitmap.createBitmap(IMAGE_WIDTH, IMAGE_HEIGHT, Bitmap.Config.ARGB_8888);
             Canvas canvas = new Canvas(bitmap);

             mActivity.setContentView(R.layout.animated_vector_drawable_source);
             ImageView imageView = (ImageView) mActivity.findViewById(R.id.avd_view);
             imageView.setLayerType(mLayerType, null);
             imageView.setImageDrawable(d1);
             d1.start();
             d1.stop();
             d1.setBounds(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT);
             bitmap.eraseColor(0);
             d1.draw(canvas);
             int endColor = bitmap.getPixel(IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2);
             assertEquals("Center point's color must be green", 0xFF00FF00, endColor);
         });
     }

     @MediumTest
     @Test
     public void testEmptyAnimatorSet() throws Throwable {
         int resId = R.drawable.avd_empty_animator;
         final Animatable2Callback callback = new Animatable2Callback();
         final AnimatedVectorDrawable d1 =
                 (AnimatedVectorDrawable) mResources.getDrawable(resId);
         d1.registerAnimationCallback(callback);
         mActivityRule.runOnUiThread(() -> {
             mActivity.setContentView(R.layout.animated_vector_drawable_source);
             ImageView imageView = (ImageView) mActivity.findViewById(R.id.avd_view);
             imageView.setLayerType(mLayerType, null);
             imageView.setImageDrawable(d1);
             d1.registerAnimationCallback(callback);
             d1.start();
         });
         Assert.assertTrue(callback.waitForStart());
         AnimatedVectorDrawableTest.waitForAVDStop(callback, MAX_TIMEOUT_MS);
         // Check that the AVD with empty AnimatorSet has finished
         callback.assertEnded(true);
         callback.assertAVDRuntime(0, TimeUnit.MILLISECONDS.toNanos(64)); // 4 frames
     }

     // Does a fuzzy comparison between two images.
     private static boolean isAlmostIdenticalInRect(Bitmap image1, Bitmap image2) {
         if (image1 == null || image2 == null) {
             return false;
         }

         if (image1.getWidth() != image2.getWidth() || image1.getHeight() != image2.getHeight()) {
             throw new IllegalArgumentException("Images size are not the same. image1:" + image1
                     + "image2:" + image2);
         }

         Rect rangeRect = new Rect(0, 0, image1.getWidth(), image1.getHeight());

         for (int x = rangeRect.left; x < rangeRect.right; x++) {
             for (int y = rangeRect.top; y < rangeRect.bottom; y++) {
                 if (image1.getPixel(x, y) != image2.getPixel(x, y)) {
                     return false;
                 }
                 int color1 = image1.getPixel(x, y);
                 int color2 = image2.getPixel(x, y);
                 int rDiff = Math.abs(Color.red(color1) - Color.red(color2));
                 int gDiff = Math.abs(Color.green(color1) - Color.green(color2));
                 int bDiff = Math.abs(Color.blue(color1) - Color.blue(color2));
                 if (rDiff + gDiff + bDiff > 8) {
                     return false;
                 }
             }
         }
         return true;
     }

     @Test
     public void testInfiniteAVD() throws Throwable {
         final Animatable2Callback callback = new Animatable2Callback();
         // Can't simply use final here, b/c it needs to be initialized and referred later in UI
         // thread.
         final ImageView[] imageView = new ImageView[1];
         mActivityRule.runOnUiThread(() -> {
             mActivity.setContentView(R.layout.fixed_sized_imageview);
             imageView[0] = (ImageView) mActivity.findViewById(R.id.imageview);
         });
         WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, imageView[0],
                 (Runnable) () -> {
                     imageView[0].setImageDrawable(mResources.getDrawable(R.drawable.infinite_avd));
                     imageView[0].setLayerType(mLayerType, null);
                     AnimatedVectorDrawable avd = (AnimatedVectorDrawable) imageView[0].getDrawable();
                     avd.registerAnimationCallback(callback);

                     avd.start();
                 });

         callback.waitForStart();
         waitWhilePumpingFrames(5, imageView[0], 200);
         Bitmap lastScreenShot = null;
         final Rect srcRect = new Rect();
         mActivityRule.runOnUiThread(() -> {
             mActivity.findViewById(R.id.imageview).getGlobalVisibleRect(srcRect);
         });

         for (int counter = 0; counter < 10; counter++) {
             // Take a screen shot every 100ms, and compare with previous screenshot for the ImageView
             // content, to make sure the AVD is animating when set on HW layer.
             Bitmap screenShot = takeScreenshot(srcRect);
             boolean isIdentical = isAlmostIdenticalInRect(screenShot, lastScreenShot);
             if (isIdentical) {
                 String outputFolder = mActivity.getExternalFilesDir(null).getAbsolutePath();
                 DrawableTestUtils.saveVectorDrawableIntoPNG(screenShot, outputFolder,
                         "inf_avd_screenshot_" + mLayerType + "_" + counter);
                 DrawableTestUtils.saveVectorDrawableIntoPNG(lastScreenShot, outputFolder,
                         "inf_avd_screenshot_" + mLayerType + "_" + (counter - 1));
                 fail("Two consecutive screenshots of AVD are identical, AVD is "
                         + "likely not animating");
             }
             lastScreenShot = screenShot;
             counter++;

             // Wait 100ms before the next screen shot. If animation ended during the wait, fail the
             // test, as the infinite avd should not end until we call stop().
             if (callback.waitForEnd(100)) {
                 fail("Infinite AnimatedVectorDrawable should not end on its own.");
             }
         }
         Assert.assertFalse(callback.endIsCalled());
         mActivityRule.runOnUiThread(() -> {
             AnimatedVectorDrawable avd = (AnimatedVectorDrawable) imageView[0].getDrawable();
             avd.stop();
         });
     }

     // Copy the source rectangle from the screen into the returned bitmap.
     private Bitmap takeScreenshot(Rect srcRect) {
         SynchronousPixelCopy copy = new SynchronousPixelCopy();
         Bitmap dest = Bitmap.createBitmap(
                 srcRect.width(), srcRect.height(), Bitmap.Config.ARGB_8888);
         int copyResult = copy.request(mActivity.getWindow(), srcRect, dest);
         Assert.assertEquals(PixelCopy.SUCCESS, copyResult);
         return dest;
     }
 }
	/*
	* Copyright (C) 2016 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.graphics.drawable.cts;

	import static junit.framework.TestCase.assertTrue;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.fail;

	import android.app.Activity;
	import android.content.res.Resources;
	import android.graphics.Bitmap;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Rect;
	import android.graphics.cts.R;
	import android.graphics.drawable.AnimatedVectorDrawable;
	import android.util.Log;
	import android.view.PixelCopy;
	import android.view.View;
	import android.widget.ImageView;

	import androidx.test.InstrumentationRegistry;
	import androidx.test.filters.LargeTest;
	import androidx.test.filters.MediumTest;
	import androidx.test.filters.SmallTest;
	import androidx.test.rule.ActivityTestRule;

	import com.android.compatibility.common.util.SynchronousPixelCopy;
	import com.android.compatibility.common.util.SystemUtil;
	import com.android.compatibility.common.util.WidgetTestUtils;

	import org.junit.AfterClass;
	import org.junit.Assert;
	import org.junit.Before;
	import org.junit.BeforeClass;
	import org.junit.Rule;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.Parameterized;

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

	@LargeTest
	@RunWith(Parameterized.class)
	public class AnimatedVectorDrawableParameterizedTest {
	@Rule
	public ActivityTestRule<DrawableStubActivity> mActivityRule =
	new ActivityTestRule<>(DrawableStubActivity.class);

	private static final int IMAGE_WIDTH = 64;
	private static final int IMAGE_HEIGHT = 64;
	private static final long MAX_TIMEOUT_MS = 1000;

	private static float sTransitionScaleBefore = Float.NaN;

	private Activity mActivity = null;
	private Resources mResources = null;
	private final int mLayerType;

	@Parameterized.Parameters
	public static Object[] data() {
	return new Object[] {
	View.LAYER_TYPE_HARDWARE,
	View.LAYER_TYPE_NONE,
	View.LAYER_TYPE_SOFTWARE
	};
	}

	@BeforeClass
	public static void setUpClass() throws Exception {
	try {
	sTransitionScaleBefore = Float.parseFloat(SystemUtil.runShellCommand(
	InstrumentationRegistry.getInstrumentation(),
	"settings get global transition_animation_scale"));

	SystemUtil.runShellCommand(InstrumentationRegistry.getInstrumentation(),
	"settings put global transition_animation_scale 0");
	} catch (NumberFormatException e) {
	Log.e("AnimatedVectorDrawableTest", "Could not read transition_animation_scale", e);
	sTransitionScaleBefore = Float.NaN;
	}
	}

	@AfterClass
	public static void tearDownClass() throws Exception {
	if (!Float.isNaN(sTransitionScaleBefore)) {
	SystemUtil.runShellCommand(InstrumentationRegistry.getInstrumentation(),
	"settings put global transition_animation_scale " +
	sTransitionScaleBefore);
	}
	}

	public AnimatedVectorDrawableParameterizedTest(final int layerType) throws Throwable {
	mLayerType = layerType;
	}

	@Before
	public void setup() {
	mActivity = mActivityRule.getActivity();
	mResources = mActivity.getResources();
	}

	@Test
	public void testAnimationOnLayer() throws Throwable {
	final Animatable2Callback callback = new Animatable2Callback();
	// Can't simply use final here, b/c it needs to be initialized and referred later in UI
	// thread.
	final ImageView[] imageView = new ImageView[1];
	mActivityRule.runOnUiThread(() -> {
	mActivity.setContentView(R.layout.fixed_sized_imageview);
	imageView[0] = (ImageView) mActivity.findViewById(R.id.imageview);
	});
	WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, imageView[0],
	(Runnable) () -> {
	imageView[0].setImageDrawable(
	mResources.getDrawable(R.drawable.animated_vector_favorite));
	imageView[0].setLayerType(mLayerType, null);
	AnimatedVectorDrawable avd =
	(AnimatedVectorDrawable) imageView[0].getDrawable();
	avd.registerAnimationCallback(callback);
	avd.start();
	});
	callback.waitForStart();
	waitWhilePumpingFrames(5, imageView[0], 200);

	Bitmap lastScreenShot = null;
	final Rect srcRect = new Rect();
	mActivityRule.runOnUiThread(() -> {
	imageView[0].getGlobalVisibleRect(srcRect);
	});

	int counter = 0;
	while (!callback.endIsCalled()) {
	// Take a screen shot every 50ms, and compare with previous screenshot for the ImageView
	// content, to make sure the AVD is animating when set on HW layer.
	Bitmap screenShot = takeScreenshot(srcRect);
	if (callback.endIsCalled()) {
	// Animation already ended, the screenshot may not contain valid animation content,
	// skip the comparison.
	break;
	}
	counter++;
	boolean isIdentical = isAlmostIdenticalInRect(screenShot, lastScreenShot);
	if (isIdentical) {
	String outputFolder = mActivity.getExternalFilesDir(null).getAbsolutePath();
	DrawableTestUtils.saveVectorDrawableIntoPNG(screenShot, outputFolder,
	"screenshot_" + counter);
	DrawableTestUtils.saveVectorDrawableIntoPNG(lastScreenShot, outputFolder,
	"screenshot_" + (counter - 1));
	fail("Two consecutive screenshots of AVD are identical, AVD is "
	+ "likely not animating");
	}
	lastScreenShot = screenShot;

	// Wait 50ms before the next screen shot. If animation ended during the wait, exit the
	// loop.
	if (callback.waitForEnd(50)) {
	break;
	}
	}
	// In this test, we want to make sure that we at least have 5 screenshots.
	assertTrue(counter >= 5);

	mActivityRule.runOnUiThread(() -> {
	AnimatedVectorDrawable avd = (AnimatedVectorDrawable) imageView[0].getDrawable();
	avd.stop();
	});
	}

	// Pump frames by repeatedly invalidating the given view. Return true if successfully pumped
	// the given number of frames before timeout, false otherwise.
	private boolean waitWhilePumpingFrames(int frameCount, final View view, long timeout)
	throws Throwable {
	final CountDownLatch frameLatch = new CountDownLatch(frameCount);
	mActivityRule.runOnUiThread(() -> {
	view.getViewTreeObserver().addOnPreDrawListener(() -> {
	if (frameLatch.getCount() > 0) {
	frameLatch.countDown();
	view.postInvalidate();
	}
	return true;
	});
	});
	return frameLatch.await(timeout, TimeUnit.MILLISECONDS);
	}

	@SmallTest
	@Test
	public void testSingleFrameAnimation() throws Throwable {
	int resId = R.drawable.avd_single_frame;
	final AnimatedVectorDrawable d1 =
	(AnimatedVectorDrawable) mResources.getDrawable(resId);
	// The AVD has a duration as 16ms.
	mActivityRule.runOnUiThread(() -> {
	Bitmap bitmap =
	Bitmap.createBitmap(IMAGE_WIDTH, IMAGE_HEIGHT, Bitmap.Config.ARGB_8888);
	Canvas canvas = new Canvas(bitmap);

	mActivity.setContentView(R.layout.animated_vector_drawable_source);
	ImageView imageView = (ImageView) mActivity.findViewById(R.id.avd_view);
	imageView.setLayerType(mLayerType, null);
	imageView.setImageDrawable(d1);
	d1.start();
	d1.stop();
	d1.setBounds(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT);
	bitmap.eraseColor(0);
	d1.draw(canvas);
	int endColor = bitmap.getPixel(IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2);
	assertEquals("Center point's color must be green", 0xFF00FF00, endColor);
	});
	}

	@MediumTest
	@Test
	public void testEmptyAnimatorSet() throws Throwable {
	int resId = R.drawable.avd_empty_animator;
	final Animatable2Callback callback = new Animatable2Callback();
	final AnimatedVectorDrawable d1 =
	(AnimatedVectorDrawable) mResources.getDrawable(resId);
	d1.registerAnimationCallback(callback);
	mActivityRule.runOnUiThread(() -> {
	mActivity.setContentView(R.layout.animated_vector_drawable_source);
	ImageView imageView = (ImageView) mActivity.findViewById(R.id.avd_view);
	imageView.setLayerType(mLayerType, null);
	imageView.setImageDrawable(d1);
	d1.registerAnimationCallback(callback);
	d1.start();
	});
	Assert.assertTrue(callback.waitForStart());
	AnimatedVectorDrawableTest.waitForAVDStop(callback, MAX_TIMEOUT_MS);
	// Check that the AVD with empty AnimatorSet has finished
	callback.assertEnded(true);
	callback.assertAVDRuntime(0, TimeUnit.MILLISECONDS.toNanos(64)); // 4 frames
	}

	// Does a fuzzy comparison between two images.
	private static boolean isAlmostIdenticalInRect(Bitmap image1, Bitmap image2) {
	if (image1 == null \|\| image2 == null) {
	return false;
	}

	if (image1.getWidth() != image2.getWidth() \|\| image1.getHeight() != image2.getHeight()) {
	throw new IllegalArgumentException("Images size are not the same. image1:" + image1
	+ "image2:" + image2);
	}

	Rect rangeRect = new Rect(0, 0, image1.getWidth(), image1.getHeight());

	for (int x = rangeRect.left; x < rangeRect.right; x++) {
	for (int y = rangeRect.top; y < rangeRect.bottom; y++) {
	if (image1.getPixel(x, y) != image2.getPixel(x, y)) {
	return false;
	}
	int color1 = image1.getPixel(x, y);
	int color2 = image2.getPixel(x, y);
	int rDiff = Math.abs(Color.red(color1) - Color.red(color2));
	int gDiff = Math.abs(Color.green(color1) - Color.green(color2));
	int bDiff = Math.abs(Color.blue(color1) - Color.blue(color2));
	if (rDiff + gDiff + bDiff > 8) {
	return false;
	}
	}
	}
	return true;
	}

	@Test
	public void testInfiniteAVD() throws Throwable {
	final Animatable2Callback callback = new Animatable2Callback();
	// Can't simply use final here, b/c it needs to be initialized and referred later in UI
	// thread.
	final ImageView[] imageView = new ImageView[1];
	mActivityRule.runOnUiThread(() -> {
	mActivity.setContentView(R.layout.fixed_sized_imageview);
	imageView[0] = (ImageView) mActivity.findViewById(R.id.imageview);
	});
	WidgetTestUtils.runOnMainAndDrawSync(mActivityRule, imageView[0],
	(Runnable) () -> {
	imageView[0].setImageDrawable(mResources.getDrawable(R.drawable.infinite_avd));
	imageView[0].setLayerType(mLayerType, null);
	AnimatedVectorDrawable avd = (AnimatedVectorDrawable) imageView[0].getDrawable();
	avd.registerAnimationCallback(callback);

	avd.start();
	});

	callback.waitForStart();
	waitWhilePumpingFrames(5, imageView[0], 200);
	Bitmap lastScreenShot = null;
	final Rect srcRect = new Rect();
	mActivityRule.runOnUiThread(() -> {
	mActivity.findViewById(R.id.imageview).getGlobalVisibleRect(srcRect);
	});

	for (int counter = 0; counter < 10; counter++) {
	// Take a screen shot every 100ms, and compare with previous screenshot for the ImageView
	// content, to make sure the AVD is animating when set on HW layer.
	Bitmap screenShot = takeScreenshot(srcRect);
	boolean isIdentical = isAlmostIdenticalInRect(screenShot, lastScreenShot);
	if (isIdentical) {
	String outputFolder = mActivity.getExternalFilesDir(null).getAbsolutePath();
	DrawableTestUtils.saveVectorDrawableIntoPNG(screenShot, outputFolder,
	"inf_avd_screenshot_" + mLayerType + "_" + counter);
	DrawableTestUtils.saveVectorDrawableIntoPNG(lastScreenShot, outputFolder,
	"inf_avd_screenshot_" + mLayerType + "_" + (counter - 1));
	fail("Two consecutive screenshots of AVD are identical, AVD is "
	+ "likely not animating");
	}
	lastScreenShot = screenShot;
	counter++;

	// Wait 100ms before the next screen shot. If animation ended during the wait, fail the
	// test, as the infinite avd should not end until we call stop().
	if (callback.waitForEnd(100)) {
	fail("Infinite AnimatedVectorDrawable should not end on its own.");
	}
	}
	Assert.assertFalse(callback.endIsCalled());
	mActivityRule.runOnUiThread(() -> {
	AnimatedVectorDrawable avd = (AnimatedVectorDrawable) imageView[0].getDrawable();
	avd.stop();
	});
	}

	// Copy the source rectangle from the screen into the returned bitmap.
	private Bitmap takeScreenshot(Rect srcRect) {
	SynchronousPixelCopy copy = new SynchronousPixelCopy();
	Bitmap dest = Bitmap.createBitmap(
	srcRect.width(), srcRect.height(), Bitmap.Config.ARGB_8888);
	int copyResult = copy.request(mActivity.getWindow(), srcRect, dest);
	Assert.assertEquals(PixelCopy.SUCCESS, copyResult);
	return dest;
	}
	}