Home | History | Annotate | Download | only in cts 
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.view.animation.cts;
     18 
     19 import android.app.Activity;
     20 import android.content.res.XmlResourceParser;
     21 import android.test.ActivityInstrumentationTestCase2;
     22 import android.util.AttributeSet;
     23 import android.util.Xml;
     24 import android.view.View;
     25 import android.view.animation.AlphaAnimation;
     26 import android.view.animation.Animation;
     27 import android.view.animation.AnimationUtils;
     28 import android.view.animation.CycleInterpolator;
     29 import android.view.animation.Interpolator;
     30 import android.view.animation.Transformation;
     31 
     32 import com.android.cts.stub.R;
     33 
     34 import dalvik.annotation.TestLevel;
     35 import dalvik.annotation.TestTargetClass;
     36 import dalvik.annotation.TestTargetNew;
     37 import dalvik.annotation.TestTargets;
     38 
     39 /**
     40  * Test {@link CycleInterpolator}.
     41  */
     42 @TestTargetClass(CycleInterpolator.class)
     43 public class CycleInterpolatorTest
     44         extends ActivityInstrumentationTestCase2<AnimationTestStubActivity> {
     45 
     46     private Activity mActivity;
     47 
     48     /** It is defined in R.anim.cycle_alpha */
     49     private static final long CYCLE_ALPHA_DURATION = 2000;
     50     private static final float ALPHA_DELTA = 0.001f;
     51 
     52     public CycleInterpolatorTest() {
     53         super("com.android.cts.stub", AnimationTestStubActivity.class);
     54     }
     55 
     56     @Override
     57     protected void setUp() throws Exception {
     58         super.setUp();
     59         mActivity = getActivity();
     60     }
     61 
     62     @TestTargets({
     63         @TestTargetNew(
     64             level = TestLevel.COMPLETE,
     65             method = "CycleInterpolator",
     66             args = {float.class}
     67         ),
     68         @TestTargetNew(
     69             level = TestLevel.COMPLETE,
     70             method = "CycleInterpolator",
     71             args = {android.content.Context.class, android.util.AttributeSet.class}
     72         )
     73     })
     74     public void testConstructors() {
     75         new CycleInterpolator(1.0f);
     76 
     77         XmlResourceParser parser = mActivity.getResources().getAnimation(R.anim.cycle_alpha);
     78         AttributeSet attrs = Xml.asAttributeSet(parser);
     79         new CycleInterpolator(mActivity, attrs);
     80     }
     81 
     82     public void testCycyleInterpolator() {
     83         final View animWindow = mActivity.findViewById(R.id.anim_window);
     84         final Animation anim = AnimationUtils.loadAnimation(mActivity, R.anim.cycle_alpha);
     85         assertEquals(CYCLE_ALPHA_DURATION, anim.getDuration());
     86         assertTrue(anim instanceof AlphaAnimation);
     87 
     88         // cycle only once.
     89         Interpolator interpolator = new CycleInterpolator(1.0f);
     90         anim.setInterpolator(interpolator);
     91         assertFalse(anim.hasStarted());
     92 
     93         AnimationTestUtils.assertRunAnimation(getInstrumentation(), animWindow, anim);
     94 
     95         Transformation transformation = new Transformation();
     96         long startTime = anim.getStartTime();
     97         anim.getTransformation(startTime, transformation);
     98         final float alpha1 = transformation.getAlpha();
     99         assertEquals(0.0f, alpha1, ALPHA_DELTA);
    100 
    101         anim.getTransformation(startTime + 500, transformation);
    102         final float alpha2 = transformation.getAlpha();
    103         assertEquals(1.0f, alpha2, ALPHA_DELTA);
    104 
    105         anim.getTransformation(startTime + 1000, transformation);
    106         final float alpha3 = transformation.getAlpha();
    107 
    108         anim.getTransformation(startTime + 1500, transformation);
    109         final float alpha4 = transformation.getAlpha();
    110         assertEquals(-1.0f, alpha4, ALPHA_DELTA);
    111 
    112         anim.getTransformation(startTime + CYCLE_ALPHA_DURATION, transformation);
    113         final float alpha5 = transformation.getAlpha();
    114         assertEquals(0.0f, alpha5, ALPHA_DELTA);
    115 
    116         // check cycle sinusoidal delta alpha
    117         final float delta1 = alpha2 - alpha1;
    118         final float delta2 = alpha3 - alpha2;
    119         final float delta3 = alpha4 - alpha3;
    120         final float delta4 = alpha5 - alpha4;
    121         assertEquals(alpha1, alpha3, ALPHA_DELTA);
    122         assertEquals(alpha3, alpha5, ALPHA_DELTA);
    123         assertEquals(alpha2, -alpha4, ALPHA_DELTA);
    124         assertEquals(delta1, -delta2, ALPHA_DELTA);
    125         assertEquals(delta2, delta3, ALPHA_DELTA);
    126         assertEquals(delta3, -delta4, ALPHA_DELTA);
    127 
    128         // cycle twice.
    129         interpolator = new CycleInterpolator(2.0f);
    130         anim.setInterpolator(interpolator);
    131 
    132         AnimationTestUtils.assertRunAnimation(getInstrumentation(), animWindow, anim);
    133 
    134         transformation = new Transformation();
    135         startTime = anim.getStartTime();
    136         anim.getTransformation(startTime, transformation);
    137         final float alpha6 = transformation.getAlpha();
    138         assertEquals(0.0f, alpha1, ALPHA_DELTA);
    139 
    140         anim.getTransformation(startTime + 250, transformation);
    141         final float alpha7 = transformation.getAlpha();
    142         assertEquals(1.0f, alpha7, ALPHA_DELTA);
    143 
    144         anim.getTransformation(startTime + 500, transformation);
    145         final float alpha8 = transformation.getAlpha();
    146 
    147         anim.getTransformation(startTime + 750, transformation);
    148         final float alpha9 = transformation.getAlpha();
    149         assertEquals(-1.0f, alpha9, ALPHA_DELTA);
    150 
    151         anim.getTransformation(startTime + 1000, transformation);
    152         final float alpha10 = transformation.getAlpha();
    153 
    154         anim.getTransformation(startTime + 1250, transformation);
    155         final float alpha11 = transformation.getAlpha();
    156 
    157         anim.getTransformation(startTime + 1500, transformation);
    158         final float alpha12 = transformation.getAlpha();
    159 
    160         anim.getTransformation(startTime + 1750, transformation);
    161         final float alpha13 = transformation.getAlpha();
    162 
    163         anim.getTransformation(startTime + CYCLE_ALPHA_DURATION, transformation);
    164         final float alpha14 = transformation.getAlpha();
    165         assertEquals(0.0f, alpha14, ALPHA_DELTA);
    166 
    167         // check cycle sinusoidal delta alpha
    168         final float delta5 = alpha7 - alpha6;
    169         final float delta6 = alpha8 - alpha7;
    170         final float delta7 = alpha9 - alpha8;
    171         final float delta8 = alpha10 - alpha9;
    172         final float delta9 = alpha11 - alpha10;
    173         final float delta10 = alpha12 - alpha11;
    174         final float delta11 = alpha13 - alpha12;
    175         final float delta12 = alpha14 - alpha13;
    176         assertEquals(alpha6, alpha8, ALPHA_DELTA);
    177         assertEquals(alpha8, alpha10, ALPHA_DELTA);
    178         assertEquals(alpha10, alpha12, ALPHA_DELTA);
    179         assertEquals(alpha12, alpha14, ALPHA_DELTA);
    180         assertEquals(alpha7, -alpha9, ALPHA_DELTA);
    181         assertEquals(alpha9, -alpha11, ALPHA_DELTA);
    182         assertEquals(alpha11, -alpha13, ALPHA_DELTA);
    183         assertEquals(delta6, -delta5, ALPHA_DELTA);
    184         assertEquals(delta7, delta6, ALPHA_DELTA);
    185         assertEquals(delta8, -delta7, ALPHA_DELTA);
    186         assertEquals(delta9, delta8, ALPHA_DELTA);
    187         assertEquals(delta10, -delta9, ALPHA_DELTA);
    188         assertEquals(delta11, delta10, ALPHA_DELTA);
    189         assertEquals(delta12, -delta11, ALPHA_DELTA);
    190 
    191         // check whether it cycle the same
    192         assertEquals(alpha6, alpha1, ALPHA_DELTA);
    193         assertEquals(alpha7, alpha2, ALPHA_DELTA);
    194         assertEquals(alpha8, alpha3, ALPHA_DELTA);
    195         assertEquals(alpha9, alpha4, ALPHA_DELTA);
    196         assertEquals(alpha10, alpha5, ALPHA_DELTA);
    197         assertEquals(alpha10, alpha1, ALPHA_DELTA);
    198         assertEquals(alpha11, alpha2, ALPHA_DELTA);
    199         assertEquals(alpha12, alpha3, ALPHA_DELTA);
    200         assertEquals(alpha13, alpha4, ALPHA_DELTA);
    201         assertEquals(alpha14, alpha5, ALPHA_DELTA);
    202         assertEquals(delta5, delta1, ALPHA_DELTA);
    203         assertEquals(delta6, delta2, ALPHA_DELTA);
    204         assertEquals(delta7, delta3, ALPHA_DELTA);
    205         assertEquals(delta8, delta4, ALPHA_DELTA);
    206         assertEquals(delta9, delta1, ALPHA_DELTA);
    207         assertEquals(delta10, delta2, ALPHA_DELTA);
    208         assertEquals(delta11, delta3, ALPHA_DELTA);
    209         assertEquals(delta12, delta4, ALPHA_DELTA);
    210     }
    211 
    212     @TestTargetNew(
    213         level = TestLevel.COMPLETE,
    214         method = "getInterpolation",
    215         args = {float.class}
    216     )
    217     public void testGetInterpolation() {
    218         CycleInterpolator cycleInterpolator = new CycleInterpolator(2.0f);
    219         final float out1 = cycleInterpolator.getInterpolation(0.0f);
    220         final float out2 = cycleInterpolator.getInterpolation(0.125f);
    221         final float out3 = cycleInterpolator.getInterpolation(0.25f);
    222         final float out4 = cycleInterpolator.getInterpolation(0.375f);
    223         final float out5 = cycleInterpolator.getInterpolation(0.5f);
    224         final float out6 = cycleInterpolator.getInterpolation(0.625f);
    225         final float out7 = cycleInterpolator.getInterpolation(0.75f);
    226         final float out8 = cycleInterpolator.getInterpolation(0.875f);
    227         final float out9 = cycleInterpolator.getInterpolation(1.0f);
    228         final float delta1 = out2 - out1;
    229         final float delta2 = out3 - out2;
    230         final float delta3 = out4 - out3;
    231         final float delta4 = out5 - out4;
    232         final float delta5 = out6 - out5;
    233         final float delta6 = out7 - out6;
    234         final float delta7 = out8 - out7;
    235         final float delta8 = out9 - out8;
    236         assertEquals(out1, out3, ALPHA_DELTA);
    237         assertEquals(out3, out5, ALPHA_DELTA);
    238         assertEquals(out5, out7, ALPHA_DELTA);
    239         assertEquals(out7, out9, ALPHA_DELTA);
    240         assertEquals(delta1, -delta2, ALPHA_DELTA);
    241         assertEquals(delta2, delta3, ALPHA_DELTA);
    242         assertEquals(delta3, -delta4, ALPHA_DELTA);
    243         assertEquals(delta4, delta5, ALPHA_DELTA);
    244         assertEquals(delta5, -delta6, ALPHA_DELTA);
    245         assertEquals(delta6, delta7, ALPHA_DELTA);
    246         assertEquals(delta7, -delta8, ALPHA_DELTA);
    247 
    248         final float timeDelta = 0.015f;
    249         assertEquals(cycleInterpolator.getInterpolation(0.0f + timeDelta),
    250                 cycleInterpolator.getInterpolation(0.5f + timeDelta), ALPHA_DELTA);
    251         assertEquals(cycleInterpolator.getInterpolation(0.25f + timeDelta),
    252                 cycleInterpolator.getInterpolation(0.75f + timeDelta), ALPHA_DELTA);
    253     }
    254 }
    255