/*
 * Copyright (C) 2012 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.animation.cts;

import static com.android.compatibility.common.util.CtsMockitoUtils.within;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ArgbEvaluator;
import android.animation.Keyframe;
import android.animation.ObjectAnimator;
import android.animation.PropertyValuesHolder;
import android.animation.TypeConverter;
import android.animation.ValueAnimator;
import android.app.Instrumentation;
import android.graphics.Color;
import android.graphics.Path;
import android.graphics.PointF;
import android.graphics.drawable.ShapeDrawable;
import android.os.SystemClock;
import android.support.test.InstrumentationRegistry;
import android.support.test.filters.LargeTest;
import android.support.test.rule.ActivityTestRule;
import android.support.test.runner.AndroidJUnit4;
import android.util.FloatProperty;
import android.util.Property;
import android.view.View;
import android.view.animation.AccelerateInterpolator;

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

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

@LargeTest
@RunWith(AndroidJUnit4.class)
public class PropertyValuesHolderTest {
    private static final float LINE1_START = -32f;
    private static final float LINE1_END = -2f;
    private static final float LINE2_START = 2f;
    private static final float LINE2_END = 12f;
    private static final float QUADRATIC_CTRL_PT1_X = 0f;
    private static final float QUADRATIC_CTRL_PT1_Y = 0f;
    private static final float QUADRATIC_CTRL_PT2_X = 50f;
    private static final float QUADRATIC_CTRL_PT2_Y = 20f;
    private static final float QUADRATIC_CTRL_PT3_X = 100f;
    private static final float QUADRATIC_CTRL_PT3_Y = 0f;
    private static final float EPSILON = .001f;

    private Instrumentation mInstrumentation;
    private AnimationActivity mActivity;
    private long mDuration = 1000;
    private float mStartY;
    private float mEndY;
    private Object mObject;
    private String mProperty;

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

    @Before
    public void setup() {
        mInstrumentation = InstrumentationRegistry.getInstrumentation();
        mInstrumentation.setInTouchMode(false);
        mActivity = mActivityRule.getActivity();
        mProperty = "y";
        mStartY = mActivity.mStartY;
        mEndY = mActivity.mStartY + mActivity.mDeltaY;
        mObject = mActivity.view.newBall;
    }

    @Test
    public void testGetPropertyName() {
        float[] values = {mStartY, mEndY};
        PropertyValuesHolder pVHolder = PropertyValuesHolder.ofFloat(mProperty, values);
        assertEquals(mProperty, pVHolder.getPropertyName());
    }

    @Test
    public void testSetPropertyName() {
        float[] values = {mStartY, mEndY};
        PropertyValuesHolder pVHolder = PropertyValuesHolder.ofFloat("", values);
        pVHolder.setPropertyName(mProperty);
        assertEquals(mProperty, pVHolder.getPropertyName());
    }

    @Test
    public void testClone() {
        float[] values = {mStartY, mEndY};
        PropertyValuesHolder pVHolder = PropertyValuesHolder.ofFloat(mProperty, values);
        PropertyValuesHolder cloneHolder = pVHolder.clone();
        assertEquals(pVHolder.getPropertyName(), cloneHolder.getPropertyName());
    }

    @Test
    public void testSetValues() throws Throwable {
        float[] dummyValues = {100, 150};
        float[] values = {mStartY, mEndY};
        PropertyValuesHolder pVHolder = PropertyValuesHolder.ofFloat(mProperty, dummyValues);
        pVHolder.setFloatValues(values);

        ObjectAnimator objAnimator = ObjectAnimator.ofPropertyValuesHolder(mObject,pVHolder);
        assertTrue(objAnimator != null);
        setAnimatorProperties(objAnimator);

        startAnimation(objAnimator);
        assertTrue(objAnimator != null);
        float[] yArray = getYPosition();
        assertResults(yArray, mStartY, mEndY);
    }

    private ObjectAnimator createAnimator(Keyframe... keyframes) {
        PropertyValuesHolder pVHolder = PropertyValuesHolder.ofKeyframe(mProperty, keyframes);
        ObjectAnimator objAnimator = ObjectAnimator.ofPropertyValuesHolder(mObject,pVHolder);
        objAnimator.setDuration(mDuration);
        objAnimator.setInterpolator(new AccelerateInterpolator());
        return objAnimator;
    }

    private void waitUntilFinished(ObjectAnimator objectAnimator, long timeoutMilliseconds)
            throws InterruptedException {
        final Animator.AnimatorListener listener = mock(Animator.AnimatorListener.class);
        objectAnimator.addListener(listener);
        verify(listener, within(timeoutMilliseconds)).onAnimationEnd(objectAnimator, false);
        mInstrumentation.waitForIdleSync();
    }

    private void setTarget(final Animator animator, final Object target) throws Throwable {
        mActivityRule.runOnUiThread(() -> animator.setTarget(target));
    }

    private void startSingleAnimation(final Animator animator) throws Throwable {
        mActivityRule.runOnUiThread(() -> mActivity.startSingleAnimation(animator));
    }

    @Test
    public void testResetValues() throws Throwable {
        final float initialY = mActivity.view.newBall.getY();
        Keyframe emptyKeyframe1 = Keyframe.ofFloat(.0f);
        ObjectAnimator objAnimator1 = createAnimator(emptyKeyframe1, Keyframe.ofFloat(1f, 100f));
        startSingleAnimation(objAnimator1);
        assertTrue("Keyframe should be assigned a value", emptyKeyframe1.hasValue());
        assertEquals("Keyframe should get the value from the target",
                (float) emptyKeyframe1.getValue(), initialY, 0.0f);
        waitUntilFinished(objAnimator1, mDuration * 2);
        assertEquals(100f, mActivity.view.newBall.getY(), 0.0f);
        startSingleAnimation(objAnimator1);
        waitUntilFinished(objAnimator1, mDuration * 2);

        // run another ObjectAnimator that will move the Y value to something else
        Keyframe emptyKeyframe2 = Keyframe.ofFloat(.0f);
        ObjectAnimator objAnimator2 = createAnimator(emptyKeyframe2, Keyframe.ofFloat(1f, 200f));
        startSingleAnimation(objAnimator2);
        assertTrue("Keyframe should be assigned a value", emptyKeyframe2.hasValue());
        assertEquals("Keyframe should get the value from the target",
                (float) emptyKeyframe2.getValue(), 100f, 0.0f);
        waitUntilFinished(objAnimator2, mDuration * 2);
        assertEquals(200f, mActivity.view.newBall.getY(), 0.0f);

        // re-run first object animator. since its target did not change, it should have the same
        // start value for kf1
        startSingleAnimation(objAnimator1);
        assertEquals((float) emptyKeyframe1.getValue(), initialY, 0.0f);
        waitUntilFinished(objAnimator1, mDuration * 2);

        Keyframe fullKeyframe = Keyframe.ofFloat(.0f, 333f);
        ObjectAnimator objAnimator3 = createAnimator(fullKeyframe, Keyframe.ofFloat(1f, 500f));
        startSingleAnimation(objAnimator3);
        assertEquals("When keyframe has value, should not be assigned from the target object",
                (float) fullKeyframe.getValue(), 333f, 0.0f);
        waitUntilFinished(objAnimator3, mDuration * 2);

        // now, null out the target of the first animator
        float updatedY = mActivity.view.newBall.getY();
        setTarget(objAnimator1, null);
        startSingleAnimation(objAnimator1);
        assertTrue("Keyframe should get a value", emptyKeyframe1.hasValue());
        assertEquals("Keyframe should get the updated Y value",
                (float) emptyKeyframe1.getValue(), updatedY, 0.0f);
        waitUntilFinished(objAnimator1, mDuration * 2);
        assertEquals("Animation should run as expected", 100f, mActivity.view.newBall.getY(), 0.0f);

        // now, reset the target of the fully defined animation.
        setTarget(objAnimator3, null);
        startSingleAnimation(objAnimator3);
        assertEquals("When keyframe is fully defined, its value should not change when target is"
                + " reset", (float) fullKeyframe.getValue(), 333f, 0.0f);
        waitUntilFinished(objAnimator3, mDuration * 2);

        // run the other one to change Y value
        startSingleAnimation(objAnimator2);
        waitUntilFinished(objAnimator2, mDuration * 2);
        // now, set another target w/ the same View type. it should still reset
        ShapeHolder view = new ShapeHolder(new ShapeDrawable());
        updatedY = mActivity.view.newBall.getY();
        setTarget(objAnimator1, view);
        startSingleAnimation(objAnimator1);
        assertTrue("Keyframe should get a value when target is set to another view of the same"
                + " class", emptyKeyframe1.hasValue());
        assertEquals("Keyframe should get the updated Y value when target is set to another view"
                + " of the same class", (float) emptyKeyframe1.getValue(), updatedY, 0.0f);
        waitUntilFinished(objAnimator1, mDuration * 2);
        assertEquals("Animation should run as expected", 100f, mActivity.view.newBall.getY(), 0.0f);
    }

    @Test
    public void testOfFloat() throws Throwable {
        float[] values = {mStartY, mEndY};
        PropertyValuesHolder pVHolder = PropertyValuesHolder.ofFloat(mProperty, values);
        assertNotNull(pVHolder);
        ObjectAnimator objAnimator = ObjectAnimator.ofPropertyValuesHolder(mObject,pVHolder);
        assertTrue(objAnimator != null);

        setAnimatorProperties(objAnimator);
        startAnimation(objAnimator);
        assertTrue(objAnimator != null);
        float[] yArray = getYPosition();
        assertResults(yArray, mStartY, mEndY);
    }

    @Test
    public void testOfFloat_Property() throws Throwable {
        float[] values = {mStartY, mEndY};
        ShapeHolderYProperty property=new ShapeHolderYProperty(ShapeHolder.class,"y");
        property.setObject(mObject);
        PropertyValuesHolder pVHolder = PropertyValuesHolder.ofFloat(property, values);
        assertNotNull(pVHolder);
        ObjectAnimator objAnimator = ObjectAnimator.ofPropertyValuesHolder(mObject,pVHolder);
        assertTrue(objAnimator != null);

        setAnimatorProperties(objAnimator);
        startAnimation(objAnimator);
        assertTrue(objAnimator != null);
        float[] yArray = getYPosition();
        assertResults(yArray, mStartY, mEndY);
    }

    @Test
    public void testOfInt() throws Throwable {
        int start = 0;
        int end = 10;
        int[] values = {start, end};
        PropertyValuesHolder pVHolder = PropertyValuesHolder.ofInt(mProperty, values);
        assertNotNull(pVHolder);
        final ObjectAnimator objAnimator = ObjectAnimator.ofPropertyValuesHolder(mObject,pVHolder);
        assertTrue(objAnimator != null);
        setAnimatorProperties(objAnimator);
        mActivityRule.runOnUiThread(objAnimator::start);
        SystemClock.sleep(1000);
        assertTrue(objAnimator.isRunning());
        Integer animatedValue = (Integer) objAnimator.getAnimatedValue();
        assertTrue(animatedValue >= start);
        assertTrue(animatedValue <= end);
    }

    @Test
    public void testOfInt_Property() throws Throwable{
        Object object = mActivity.view;
        String property = "backgroundColor";
        int startColor = mActivity.view.RED;
        int endColor = mActivity.view.BLUE;
        int values[] = {startColor, endColor};

        ViewColorProperty colorProperty=new ViewColorProperty(Integer.class,property);
        colorProperty.setObject(object);
        PropertyValuesHolder pVHolder = PropertyValuesHolder.ofInt(colorProperty, values);
        assertNotNull(pVHolder);

        ObjectAnimator colorAnimator = ObjectAnimator.ofPropertyValuesHolder(object,pVHolder);
        colorAnimator.setDuration(1000);
        colorAnimator.setEvaluator(new ArgbEvaluator());
        colorAnimator.setRepeatCount(ValueAnimator.INFINITE);
        colorAnimator.setRepeatMode(ValueAnimator.REVERSE);

        ObjectAnimator objectAnimator = (ObjectAnimator) mActivity.createAnimatorWithDuration(
            mDuration);
        startAnimation(objectAnimator, colorAnimator);
        SystemClock.sleep(1000);
        Integer animatedValue = (Integer) colorAnimator.getAnimatedValue();
        int redMin = Math.min(Color.red(startColor), Color.red(endColor));
        int redMax = Math.max(Color.red(startColor), Color.red(endColor));
        int blueMin = Math.min(Color.blue(startColor), Color.blue(endColor));
        int blueMax = Math.max(Color.blue(startColor), Color.blue(endColor));
        assertTrue(Color.red(animatedValue) >= redMin);
        assertTrue(Color.red(animatedValue) <= redMax);
        assertTrue(Color.blue(animatedValue) >= blueMin);
        assertTrue(Color.blue(animatedValue) <= blueMax);
    }

    @Test
    public void testOfMultiFloat_Path() throws Throwable {
        // Test for PropertyValuesHolder.ofMultiFloat(String, Path);
        // Create a quadratic bezier curve that are symmetric about the vertical line (x = 50).
        // Expect when fraction < 0.5, x < 50, otherwise, x >= 50.
        Path path = new Path();
        path.moveTo(QUADRATIC_CTRL_PT1_X, QUADRATIC_CTRL_PT1_Y);
        path.quadTo(QUADRATIC_CTRL_PT2_X, QUADRATIC_CTRL_PT2_Y,
                QUADRATIC_CTRL_PT3_X, QUADRATIC_CTRL_PT3_Y);

        PropertyValuesHolder pvh = PropertyValuesHolder.ofMultiFloat("position", path);
        final ValueAnimator anim = ValueAnimator.ofPropertyValuesHolder(pvh);

        // Linear interpolator
        anim.setInterpolator(null);
        anim.setDuration(200);

        anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            float lastFraction = 0;
            float lastX = 0;
            float lastY = 0;
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float[] values = (float[]) animation.getAnimatedValue();
                assertEquals(2, values.length);
                float x = values[0];
                float y = values[1];
                float fraction = animation.getAnimatedFraction();
                // Given that the curve is symmetric about the line (x = 50), x should be less than
                // 50 for half of the animation duration.
                if (fraction < 0.5) {
                    assertTrue(x < QUADRATIC_CTRL_PT2_X);
                } else {
                    assertTrue(x >= QUADRATIC_CTRL_PT2_X);
                }

                if (lastFraction > 0.5) {
                    // x should be increasing, y should be decreasing
                    assertTrue(x >= lastX);
                    assertTrue(y <= lastY);
                } else if (fraction <= 0.5) {
                    // when fraction <= 0.5, both x, y should be increasing
                    assertTrue(x >= lastX);
                    assertTrue(y >= lastY);
                }
                lastX = x;
                lastY = y;
                lastFraction = fraction;
            }
        });
        final Animator.AnimatorListener listener = mock(Animator.AnimatorListener.class);
        anim.addListener(listener);
        mActivityRule.runOnUiThread(anim::start);
        verify(listener, within(400)).onAnimationEnd(anim, false);
    }

    @Test
    public void testOfMultiFloat_Array() throws Throwable {
        // Test for PropertyValuesHolder.ofMultiFloat(String, float[][]);
        final float[][] data = new float[10][];
        for (int i = 0; i < data.length; i++) {
            data[i] = new float[3];
            data[i][0] = i;
            data[i][1] = i * 2;
            data[i][2] = 0f;
        }
        final CountDownLatch endLatch = new CountDownLatch(1);
        final PropertyValuesHolder pvh = PropertyValuesHolder.ofMultiFloat("position", data);

        final ValueAnimator anim = ValueAnimator.ofPropertyValuesHolder(pvh);
        anim.setInterpolator(null);
        anim.setDuration(60);
        anim.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                endLatch.countDown();
            }
        });

        anim.addUpdateListener((ValueAnimator animation) -> {
            float fraction = animation.getAnimatedFraction();
            float[] values = (float[]) animation.getAnimatedValue();
            assertEquals(3, values.length);

            float expectedX = fraction * (data.length - 1);

            assertEquals(expectedX, values[0], EPSILON);
            assertEquals(expectedX * 2, values[1], EPSILON);
            assertEquals(0.0f, values[2], 0.0f);
        });

        mActivityRule.runOnUiThread(anim::start);
        assertTrue(endLatch.await(200, TimeUnit.MILLISECONDS));
    }

    @Test
    public void testOfMultiInt_Path() throws Throwable {
        // Test for PropertyValuesHolder.ofMultiInt(String, Path);
        // Create a quadratic bezier curve that are symmetric about the vertical line (x = 50).
        // Expect when fraction < 0.5, x < 50, otherwise, x >= 50.
        Path path = new Path();
        path.moveTo(QUADRATIC_CTRL_PT1_X, QUADRATIC_CTRL_PT1_Y);
        path.quadTo(QUADRATIC_CTRL_PT2_X, QUADRATIC_CTRL_PT2_Y,
                QUADRATIC_CTRL_PT3_X, QUADRATIC_CTRL_PT3_Y);

        final PropertyValuesHolder pvh = PropertyValuesHolder.ofMultiInt("position", path);
        final ValueAnimator anim = ValueAnimator.ofPropertyValuesHolder(pvh);
        // Linear interpolator
        anim.setInterpolator(null);
        anim.setDuration(200);

        anim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            float lastFraction = 0;
            int lastX = 0;
            int lastY = 0;
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                int[] values = (int[]) animation.getAnimatedValue();
                assertEquals(2, values.length);
                int x = values[0];
                int y = values[1];
                float fraction = animation.getAnimatedFraction();
                // Given that the curve is symmetric about the line (x = 50), x should be less than
                // 50 for half of the animation duration.
                if (fraction < 0.5) {
                    assertTrue(x < QUADRATIC_CTRL_PT2_X);
                } else {
                    assertTrue(x >= QUADRATIC_CTRL_PT2_X);
                }

                if (lastFraction > 0.5) {
                    // x should be increasing, y should be decreasing
                    assertTrue(x >= lastX);
                    assertTrue(y <= lastY);
                } else if (fraction <= 0.5) {
                    // when fraction <= 0.5, both x, y should be increasing
                    assertTrue(x >= lastX);
                    assertTrue(y >= lastY);
                }
                lastX = x;
                lastY = y;
                lastFraction = fraction;
            }
        });
        final Animator.AnimatorListener listener = mock(Animator.AnimatorListener.class);
        anim.addListener(listener);
        mActivityRule.runOnUiThread(anim::start);
        verify(listener, within(400)).onAnimationEnd(anim, false);
    }

    @Test
    public void testOfMultiInt_Array() throws Throwable {
        // Test for PropertyValuesHolder.ofMultiFloat(String, int[][]);
        final int[][] data = new int[10][];
        for (int i = 0; i < data.length; i++) {
            data[i] = new int[3];
            data[i][0] = i;
            data[i][1] = i * 2;
            data[i][2] = 0;
        }

        final CountDownLatch endLatch = new CountDownLatch(1);
        final PropertyValuesHolder pvh = PropertyValuesHolder.ofMultiInt("position", data);
        final ValueAnimator anim = ValueAnimator.ofPropertyValuesHolder(pvh);
        anim.setInterpolator(null);
        anim.setDuration(60);
        anim.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                endLatch.countDown();
            }
        });

        anim.addUpdateListener((ValueAnimator animation) -> {
            float fraction = animation.getAnimatedFraction();
            int[] values = (int[]) animation.getAnimatedValue();
            assertEquals(3, values.length);

            int expectedX = Math.round(fraction * (data.length - 1));
            int expectedY = Math.round(fraction * (data.length - 1) * 2);

            // Allow a delta of 1 for rounding errors.
            assertEquals(expectedX, values[0], 1);
            assertEquals(expectedY, values[1], 1);
            assertEquals(0, values[2]);
        });

        mActivityRule.runOnUiThread(anim::start);
        assertTrue(endLatch.await(200, TimeUnit.MILLISECONDS));
    }

    @Test
    public void testOfObject_Converter() throws Throwable {
        // Test for PropertyValuesHolder.ofObject(String, TypeConverter<T, V>, Path)
        // and for PropertyValuesHolder.ofObject(Property, TypeConverter<T, V>, Path)
        // Create a path that contains two disconnected line segments. Check that the animated
        // property x and property y always stay on the line segments.
        Path path = new Path();
        path.moveTo(LINE1_START, -LINE1_START);
        path.lineTo(LINE1_END, -LINE1_END);
        path.moveTo(LINE2_START, LINE2_START);
        path.lineTo(LINE2_END, LINE2_END);
        TypeConverter<PointF, Float> converter = new TypeConverter<PointF, Float>(
                PointF.class, Float.class) {
            @Override
            public Float convert(PointF value) {
                return (float) Math.sqrt(value.x * value.x + value.y * value.y);
            }
        };
        final CountDownLatch endLatch = new CountDownLatch(3);

        // Create three animators. The first one use a converter that converts the point to distance
        // to  origin. The second one does not have a type converter. The third animator uses a
        // converter to changes sign of the x, y value of the input pointF.
        FloatProperty property = new FloatProperty("distance") {
            @Override
            public void setValue(Object object, float value) {
            }

            @Override
            public Object get(Object object) {
                return null;
            }
        };
        final PropertyValuesHolder pvh1 =
                PropertyValuesHolder.ofObject(property, converter, path);
        final ValueAnimator anim1 = ValueAnimator.ofPropertyValuesHolder(pvh1);
        anim1.setDuration(100);
        anim1.setInterpolator(null);
        anim1.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                endLatch.countDown();
            }
        });

        final PropertyValuesHolder pvh2 =
                PropertyValuesHolder.ofObject("position", null, path);
        final ValueAnimator anim2 = ValueAnimator.ofPropertyValuesHolder(pvh2);
        anim2.setDuration(100);
        anim2.setInterpolator(null);
        anim2.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                endLatch.countDown();
            }
        });

        TypeConverter<PointF, PointF> converter3 = new TypeConverter<PointF, PointF>(
                PointF.class, PointF.class) {
            PointF mValue = new PointF();
            @Override
            public PointF convert(PointF value) {
                mValue.x = -value.x;
                mValue.y = -value.y;
                return mValue;
            }
        };
        final PropertyValuesHolder pvh3 =
                PropertyValuesHolder.ofObject("position", converter3, path);
        final ValueAnimator anim3 = ValueAnimator.ofPropertyValuesHolder(pvh3);
        anim3.setDuration(100);
        anim3.setInterpolator(null);
        anim3.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                endLatch.countDown();
            }
        });

        anim3.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
            // Set the initial value of the distance to the distance between the first point on
            // the path to the origin.
            float mLastDistance = (float) (32 * Math.sqrt(2));
            float mLastFraction = 0f;
            @Override
            public void onAnimationUpdate(ValueAnimator animation) {
                float fraction = anim1.getAnimatedFraction();
                assertEquals(fraction, anim2.getAnimatedFraction(), 0.0f);
                assertEquals(fraction, anim3.getAnimatedFraction(), 0.0f);
                float distance = (Float) anim1.getAnimatedValue();
                PointF position = (PointF) anim2.getAnimatedValue();
                PointF positionReverseSign = (PointF) anim3.getAnimatedValue();
                assertEquals(position.x, -positionReverseSign.x, 0.0f);
                assertEquals(position.y, -positionReverseSign.y, 0.0f);

                // Manually calculate the distance for the animator that doesn't have a
                // TypeConverter, and expect the result to be the same as the animation value from
                // the type converter.
                float distanceFromPosition = (float) Math.sqrt(
                        position.x * position.x + position.y * position.y);
                assertEquals(distance, distanceFromPosition, 0.0001f);

                if (mLastFraction > 0.75) {
                    // In the 2nd line segment of the path, distance to origin should be increasing.
                    assertTrue(distance >= mLastDistance);
                } else if (fraction < 0.75) {
                    assertTrue(distance <= mLastDistance);
                }
                mLastDistance = distance;
                mLastFraction = fraction;
            }
        });

        mActivityRule.runOnUiThread(() -> {
            anim1.start();
            anim2.start();
            anim3.start();
        });

        // Wait until both of the animations finish
        assertTrue(endLatch.await(200, TimeUnit.MILLISECONDS));
    }

    @Test
    public void testSetConverter() throws Throwable {
        // Test for PropertyValuesHolder.setConverter()
        PropertyValuesHolder pvh = PropertyValuesHolder.ofObject("", null, 0f, 1f);
        // Reverse the sign of the float in the converter, and use that value as the new type
        // PointF's x value.
        pvh.setConverter(new TypeConverter<Float, PointF>(Float.class, PointF.class) {
            PointF mValue = new PointF();
            @Override
            public PointF convert(Float value) {
                mValue.x = value * (-1f);
                mValue.y = 0f;
                return mValue;
            }
        });
        final CountDownLatch endLatch = new CountDownLatch(2);

        final ValueAnimator anim1 = ValueAnimator.ofPropertyValuesHolder(pvh);
        anim1.setInterpolator(null);
        anim1.setDuration(100);
        anim1.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                endLatch.countDown();
            }
        });

        final ValueAnimator anim2 = ValueAnimator.ofFloat(0f, 1f);
        anim2.setInterpolator(null);
        anim2.addUpdateListener((ValueAnimator animation) -> {
            assertEquals(anim1.getAnimatedFraction(), anim2.getAnimatedFraction(), 0.0f);
            // Check that the pvh with type converter did reverse the sign of float, and set
            // the x value of the PointF with it.
            PointF value1 = (PointF) anim1.getAnimatedValue();
            float value2 = (Float) anim2.getAnimatedValue();
            assertEquals(value2, -value1.x, 0.0f);
            assertEquals(0f, value1.y, 0.0f);
        });
        anim2.setDuration(100);
        anim2.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                endLatch.countDown();
            }
        });

        mActivityRule.runOnUiThread(() -> {
            anim1.start();
            anim2.start();
        });

        // Wait until both of the animations finish
        assertTrue(endLatch.await(200, TimeUnit.MILLISECONDS));
    }

    @Test
    public void testSetProperty() throws Throwable {
        float[] values = {mStartY, mEndY};
        ShapeHolderYProperty property=new ShapeHolderYProperty(ShapeHolder.class,"y");
        property.setObject(mObject);
        PropertyValuesHolder pVHolder = PropertyValuesHolder.ofFloat("", values);
        pVHolder.setProperty(property);
        ObjectAnimator objAnimator = ObjectAnimator.ofPropertyValuesHolder(mObject,pVHolder);
        setAnimatorProperties(objAnimator);
        startAnimation(objAnimator);
        assertTrue(objAnimator != null);
        float[] yArray = getYPosition();
        assertResults(yArray, mStartY, mEndY);
    }

    class ShapeHolderYProperty extends Property {
        private ShapeHolder shapeHolder ;
        private Class type = Float.class;
        private String name = "y";
        @SuppressWarnings("unchecked")
        public ShapeHolderYProperty(Class type, String name) throws Exception {
            super(Float.class, name );
            if(!( type.equals(this.type) || ( name.equals(this.name))) ){
                throw new Exception("Type or name provided does not match with " +
                        this.type.getName() + " or " + this.name);
            }
        }

        public void setObject(Object object){
            shapeHolder = (ShapeHolder) object;
        }

        @Override
        public Object get(Object object) {
            return shapeHolder;
        }

        @Override
        public String getName() {
            return "y";
        }

        @Override
        public Class getType() {
            return super.getType();
        }

        @Override
        public boolean isReadOnly() {
            return false;
        }

        @Override
        public void set(Object object, Object value) {
            shapeHolder.setY((Float)value);
        }

    }

    class ViewColorProperty extends Property {
        private View view ;
        private Class type = Integer.class;
        private String name = "backgroundColor";
        @SuppressWarnings("unchecked")
        public ViewColorProperty(Class type, String name) throws Exception {
            super(Integer.class, name );
            if(!( type.equals(this.type) || ( name.equals(this.name))) ){
                throw new Exception("Type or name provided does not match with " +
                        this.type.getName() + " or " + this.name);
            }
        }

        public void setObject(Object object){
            view = (View) object;
        }

        @Override
        public Object get(Object object) {
            return view;
        }

        @Override
        public String getName() {
            return name;
        }

        @Override
        public Class getType() {
            return super.getType();
        }

        @Override
        public boolean isReadOnly() {
            return false;
        }

        @Override
        public void set(Object object, Object value) {
            view.setBackgroundColor((Integer)value);
        }
    }

    private void setAnimatorProperties(ObjectAnimator objAnimator) {
        objAnimator.setDuration(mDuration);
        objAnimator.setRepeatCount(ValueAnimator.INFINITE);
        objAnimator.setInterpolator(new AccelerateInterpolator());
        objAnimator.setRepeatMode(ValueAnimator.REVERSE);
    }

    public float[] getYPosition() throws Throwable{
        float[] yArray = new float[3];
        for(int i = 0; i < 3; i++) {
            float y = mActivity.view.newBall.getY();
            yArray[i] = y;
            SystemClock.sleep(300);
        }
        return yArray;
    }

    public void assertResults(float[] yArray,float startY, float endY) {
        for(int i = 0; i < 3; i++){
            float y = yArray[i];
            assertTrue(y >= startY);
            assertTrue(y <= endY);
            if(i < 2) {
                float yNext = yArray[i+1];
                assertTrue(y != yNext);
            }
        }
    }

    private void startAnimation(final Animator animator) throws Throwable {
        mActivityRule.runOnUiThread(() -> mActivity.startAnimation(animator));
    }

    private void startAnimation(final ObjectAnimator mObjectAnimator,
            final ObjectAnimator colorAnimator) throws Throwable {
        mActivityRule.runOnUiThread(() -> mActivity.startAnimation(mObjectAnimator, colorAnimator));
    }
}