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.widget.cts;
     18 
     19 import static org.junit.Assert.assertEquals;
     20 import static org.junit.Assert.assertFalse;
     21 import static org.junit.Assert.assertNull;
     22 import static org.junit.Assert.assertSame;
     23 import static org.junit.Assert.assertTrue;
     24 import static org.mockito.Matchers.any;
     25 import static org.mockito.Matchers.anyInt;
     26 import static org.mockito.Mockito.atLeastOnce;
     27 import static org.mockito.Mockito.never;
     28 import static org.mockito.Mockito.reset;
     29 import static org.mockito.Mockito.spy;
     30 import static org.mockito.Mockito.times;
     31 import static org.mockito.Mockito.verify;
     32 
     33 import android.content.Context;
     34 import android.content.res.ColorStateList;
     35 import android.graphics.BlendMode;
     36 import android.graphics.Canvas;
     37 import android.graphics.Color;
     38 import android.graphics.PorterDuff;
     39 import android.graphics.drawable.ColorDrawable;
     40 import android.graphics.drawable.Drawable;
     41 import android.os.Parcelable;
     42 import android.util.AttributeSet;
     43 import android.view.View;
     44 import android.view.animation.AccelerateDecelerateInterpolator;
     45 import android.view.animation.AccelerateInterpolator;
     46 import android.view.animation.Interpolator;
     47 import android.view.animation.LinearInterpolator;
     48 import android.widget.ProgressBar;
     49 import android.widget.cts.util.TestUtils;
     50 
     51 import androidx.test.annotation.UiThreadTest;
     52 import androidx.test.filters.SmallTest;
     53 import androidx.test.rule.ActivityTestRule;
     54 import androidx.test.runner.AndroidJUnit4;
     55 
     56 import org.junit.Before;
     57 import org.junit.Rule;
     58 import org.junit.Test;
     59 import org.junit.runner.RunWith;
     60 
     61 @SmallTest
     62 @RunWith(AndroidJUnit4.class)
     63 public class ProgressBarTest {
     64     private ProgressBarCtsActivity mActivity;
     65     private ProgressBar mProgressBar;
     66     private ProgressBar mProgressBarHorizontal;
     67 
     68     @Rule
     69     public ActivityTestRule<ProgressBarCtsActivity> mActivityRule =
     70             new ActivityTestRule<>(ProgressBarCtsActivity.class);
     71 
     72     @Before
     73     public void setup() {
     74         mActivity = mActivityRule.getActivity();
     75         mProgressBar = (ProgressBar) mActivity.findViewById(R.id.progress);
     76         mProgressBarHorizontal = (ProgressBar) mActivity.findViewById(R.id.progress_horizontal);
     77     }
     78 
     79     @Test
     80     public void testConstructor() {
     81         new ProgressBar(mActivity);
     82 
     83         new ProgressBar(mActivity, null);
     84 
     85         new ProgressBar(mActivity, null, android.R.attr.progressBarStyle);
     86 
     87         new ProgressBar(mActivity, null, android.R.attr.progressBarStyleHorizontal);
     88 
     89         new ProgressBar(mActivity, null, android.R.attr.progressBarStyleInverse);
     90 
     91         new ProgressBar(mActivity, null, android.R.attr.progressBarStyleLarge);
     92 
     93         new ProgressBar(mActivity, null, android.R.attr.progressBarStyleLargeInverse);
     94 
     95         new ProgressBar(mActivity, null, android.R.attr.progressBarStyleSmall);
     96 
     97         new ProgressBar(mActivity, null, android.R.attr.progressBarStyleSmallInverse);
     98 
     99         new ProgressBar(mActivity, null, android.R.attr.progressBarStyleSmallTitle);
    100 
    101         new ProgressBar(mActivity, null, 0, android.R.style.Widget_DeviceDefault_Light_ProgressBar);
    102 
    103         new ProgressBar(mActivity, null, 0,
    104                 android.R.style.Widget_DeviceDefault_Light_ProgressBar_Horizontal);
    105 
    106         new ProgressBar(mActivity, null, 0,
    107                 android.R.style.Widget_DeviceDefault_Light_ProgressBar_Inverse);
    108 
    109         new ProgressBar(mActivity, null, 0,
    110                 android.R.style.Widget_DeviceDefault_Light_ProgressBar_Large);
    111 
    112         new ProgressBar(mActivity, null, 0,
    113                 android.R.style.Widget_DeviceDefault_Light_ProgressBar_Large_Inverse);
    114 
    115         new ProgressBar(mActivity, null, 0,
    116                 android.R.style.Widget_DeviceDefault_Light_ProgressBar_Small);
    117 
    118         new ProgressBar(mActivity, null, 0,
    119                 android.R.style.Widget_DeviceDefault_Light_ProgressBar_Small_Inverse);
    120 
    121         new ProgressBar(mActivity, null, 0,
    122                 android.R.style.Widget_DeviceDefault_Light_ProgressBar_Small_Title);
    123 
    124         new ProgressBar(mActivity, null, 0, android.R.style.Widget_Material_Light_ProgressBar);
    125 
    126         new ProgressBar(mActivity, null, 0,
    127                 android.R.style.Widget_Material_Light_ProgressBar_Horizontal);
    128 
    129         new ProgressBar(mActivity, null, 0,
    130                 android.R.style.Widget_Material_Light_ProgressBar_Inverse);
    131 
    132         new ProgressBar(mActivity, null, 0,
    133                 android.R.style.Widget_Material_Light_ProgressBar_Large);
    134 
    135         new ProgressBar(mActivity, null, 0,
    136                 android.R.style.Widget_Material_Light_ProgressBar_Large_Inverse);
    137 
    138         new ProgressBar(mActivity, null, 0,
    139                 android.R.style.Widget_Material_Light_ProgressBar_Small);
    140 
    141         new ProgressBar(mActivity, null, 0,
    142                 android.R.style.Widget_Material_Light_ProgressBar_Small_Inverse);
    143 
    144         new ProgressBar(mActivity, null, 0,
    145                 android.R.style.Widget_Material_Light_ProgressBar_Small_Title);
    146     }
    147 
    148     @UiThreadTest
    149     @Test
    150     public void testSetIndeterminate() {
    151         assertTrue(mProgressBar.isIndeterminate());
    152 
    153         mProgressBar.setIndeterminate(true);
    154         assertTrue(mProgressBar.isIndeterminate());
    155 
    156         mProgressBar.setIndeterminate(false);
    157         // because default is Indeterminate only progressBar, can't change the status
    158         assertTrue(mProgressBar.isIndeterminate());
    159 
    160         assertFalse(mProgressBarHorizontal.isIndeterminate());
    161 
    162         mProgressBarHorizontal.setIndeterminate(true);
    163         assertTrue(mProgressBarHorizontal.isIndeterminate());
    164 
    165         mProgressBarHorizontal.setIndeterminate(false);
    166         assertFalse(mProgressBarHorizontal.isIndeterminate());
    167     }
    168 
    169     @UiThreadTest
    170     @Test
    171     public void testQueryAnimationState() {
    172         assertTrue(mProgressBar.isAnimating());
    173         assertFalse(mProgressBarHorizontal.isAnimating());
    174 
    175         mProgressBarHorizontal.setIndeterminate(true);
    176         assertTrue(mProgressBarHorizontal.isAnimating());
    177 
    178         mProgressBarHorizontal.setIndeterminate(false);
    179         assertFalse(mProgressBarHorizontal.isAnimating());
    180 
    181         mProgressBar.setVisibility(View.GONE);
    182         assertFalse(mProgressBar.isAnimating());
    183         mProgressBar.setVisibility(View.INVISIBLE);
    184         assertFalse(mProgressBar.isAnimating());
    185         mProgressBar.setVisibility(View.VISIBLE);
    186         assertTrue(mProgressBar.isAnimating());
    187     }
    188 
    189     @UiThreadTest
    190     @Test
    191     public void testAccessIndeterminateDrawable() {
    192         // set IndeterminateDrawable
    193         // normal value
    194         Drawable mockProgressDrawable = spy(new ColorDrawable(Color.YELLOW));
    195         mProgressBar.setIndeterminateDrawable(mockProgressDrawable);
    196         assertSame(mockProgressDrawable, mProgressBar.getIndeterminateDrawable());
    197         verify(mockProgressDrawable, never()).draw(any(Canvas.class));
    198         mProgressBar.draw(new Canvas());
    199         verify(mockProgressDrawable, atLeastOnce()).draw(any(Canvas.class));
    200 
    201         // exceptional value
    202         mProgressBar.setIndeterminateDrawable(null);
    203         assertNull(mProgressBar.getIndeterminateDrawable());
    204     }
    205 
    206     @UiThreadTest
    207     @Test
    208     public void testAccessProgressDrawable() {
    209         // set ProgressDrawable
    210         // normal value
    211         Drawable mockProgressDrawable = spy(new ColorDrawable(Color.BLUE));
    212         mProgressBarHorizontal.setProgressDrawable(mockProgressDrawable);
    213         assertSame(mockProgressDrawable, mProgressBarHorizontal.getProgressDrawable());
    214         verify(mockProgressDrawable, never()).draw(any(Canvas.class));
    215         mProgressBarHorizontal.draw(new Canvas());
    216         verify(mockProgressDrawable, atLeastOnce()).draw(any(Canvas.class));
    217 
    218         // exceptional value
    219         mProgressBarHorizontal.setProgressDrawable(null);
    220         assertNull(mProgressBarHorizontal.getProgressDrawable());
    221     }
    222 
    223     @UiThreadTest
    224     @Test
    225     public void testAccessCurrentDrawable() {
    226         final Drawable progressDrawable = new ColorDrawable(Color.BLUE);
    227         final Drawable indeterminateDrawable = new ColorDrawable(Color.RED);
    228         mProgressBarHorizontal.setProgressDrawable(progressDrawable);
    229         mProgressBarHorizontal.setIndeterminateDrawable(indeterminateDrawable);
    230 
    231         mProgressBarHorizontal.setIndeterminate(false);
    232         assertSame(progressDrawable, mProgressBarHorizontal.getCurrentDrawable());
    233         mProgressBarHorizontal.setIndeterminate(true);
    234         assertSame(indeterminateDrawable, mProgressBarHorizontal.getCurrentDrawable());
    235     }
    236 
    237     @UiThreadTest
    238     @Test
    239     public void testAccessProgress() {
    240         assertEquals(0, mProgressBarHorizontal.getProgress());
    241 
    242         final int maxProgress = mProgressBarHorizontal.getMax();
    243         // set Progress
    244         // normal value
    245         mProgressBarHorizontal.setProgress(maxProgress >> 1);
    246         assertEquals(maxProgress >> 1, mProgressBarHorizontal.getProgress());
    247 
    248         // exceptional values
    249         mProgressBarHorizontal.setProgress(-1);
    250         assertEquals(0, mProgressBarHorizontal.getProgress());
    251 
    252         mProgressBarHorizontal.setProgress(maxProgress + 1);
    253         assertEquals(maxProgress, mProgressBarHorizontal.getProgress());
    254 
    255         mProgressBarHorizontal.setProgress(Integer.MAX_VALUE);
    256         assertEquals(maxProgress, mProgressBarHorizontal.getProgress());
    257 
    258         mProgressBarHorizontal.setProgress(0, true);
    259         assertEquals(0, mProgressBarHorizontal.getProgress());
    260 
    261         // when in indeterminate mode
    262         mProgressBarHorizontal.setIndeterminate(true);
    263         mProgressBarHorizontal.setProgress(maxProgress >> 1);
    264         assertEquals(0, mProgressBarHorizontal.getProgress());
    265     }
    266 
    267     @UiThreadTest
    268     @Test
    269     public void testAccessSecondaryProgress() {
    270         assertEquals(0, mProgressBarHorizontal.getSecondaryProgress());
    271 
    272         final int maxProgress = mProgressBarHorizontal.getMax();
    273         // set SecondaryProgress
    274         // normal value
    275         mProgressBarHorizontal.setSecondaryProgress(maxProgress >> 1);
    276         assertEquals(maxProgress >> 1, mProgressBarHorizontal.getSecondaryProgress());
    277 
    278         // exceptional value
    279         mProgressBarHorizontal.setSecondaryProgress(-1);
    280         assertEquals(0, mProgressBarHorizontal.getSecondaryProgress());
    281 
    282         mProgressBarHorizontal.setSecondaryProgress(maxProgress + 1);
    283         assertEquals(maxProgress, mProgressBarHorizontal.getSecondaryProgress());
    284 
    285         mProgressBarHorizontal.setSecondaryProgress(Integer.MAX_VALUE);
    286         assertEquals(maxProgress, mProgressBarHorizontal.getSecondaryProgress());
    287 
    288         // when in indeterminate mode
    289         mProgressBarHorizontal.setIndeterminate(true);
    290         mProgressBarHorizontal.setSecondaryProgress(maxProgress >> 1);
    291         assertEquals(0, mProgressBarHorizontal.getSecondaryProgress());
    292     }
    293 
    294     @UiThreadTest
    295     @Test
    296     public void testIncrementProgressBy() {
    297         // normal value
    298         int increment = 1;
    299         int oldProgress = mProgressBarHorizontal.getProgress();
    300         mProgressBarHorizontal.incrementProgressBy(increment);
    301         assertEquals(oldProgress + increment, mProgressBarHorizontal.getProgress());
    302 
    303         increment = mProgressBarHorizontal.getMax() >> 1;
    304         oldProgress = mProgressBarHorizontal.getProgress();
    305         mProgressBarHorizontal.incrementProgressBy(increment);
    306         assertEquals(oldProgress + increment, mProgressBarHorizontal.getProgress());
    307 
    308         // exceptional values
    309         mProgressBarHorizontal.setProgress(0);
    310         mProgressBarHorizontal.incrementProgressBy(Integer.MAX_VALUE);
    311         assertEquals(mProgressBarHorizontal.getMax(), mProgressBarHorizontal.getProgress());
    312 
    313         mProgressBarHorizontal.setProgress(0);
    314         mProgressBarHorizontal.incrementProgressBy(Integer.MIN_VALUE);
    315         assertEquals(0, mProgressBarHorizontal.getProgress());
    316     }
    317 
    318     @UiThreadTest
    319     @Test
    320     public void testIncrementSecondaryProgressBy() {
    321         // normal value
    322         int increment = 1;
    323         int oldSecondaryProgress = mProgressBarHorizontal.getSecondaryProgress();
    324         mProgressBarHorizontal.incrementSecondaryProgressBy(increment);
    325         assertEquals(oldSecondaryProgress + increment,
    326                 mProgressBarHorizontal.getSecondaryProgress());
    327 
    328         increment = mProgressBarHorizontal.getMax() >> 1;
    329         oldSecondaryProgress = mProgressBarHorizontal.getSecondaryProgress();
    330         mProgressBarHorizontal.incrementSecondaryProgressBy(increment);
    331         assertEquals(oldSecondaryProgress + increment,
    332                 mProgressBarHorizontal.getSecondaryProgress());
    333 
    334         // exceptional values
    335         mProgressBarHorizontal.setSecondaryProgress(0);
    336         mProgressBarHorizontal.incrementSecondaryProgressBy(Integer.MAX_VALUE);
    337         assertEquals(mProgressBarHorizontal.getMax(),
    338                 mProgressBarHorizontal.getSecondaryProgress());
    339 
    340         mProgressBarHorizontal.setSecondaryProgress(0);
    341         mProgressBarHorizontal.incrementSecondaryProgressBy(Integer.MIN_VALUE);
    342         assertEquals(0, mProgressBarHorizontal.getSecondaryProgress());
    343     }
    344 
    345     @UiThreadTest
    346     @Test
    347     public void testAccessInterpolator() {
    348         // default should be LinearInterpolator
    349         assertTrue(mProgressBar.getInterpolator() instanceof LinearInterpolator);
    350 
    351         Interpolator interpolator = new AccelerateDecelerateInterpolator();
    352         mProgressBar.setInterpolator(interpolator);
    353         assertEquals(interpolator, mProgressBar.getInterpolator());
    354 
    355         mProgressBar.setInterpolator(mActivity, android.R.anim.accelerate_interpolator);
    356         assertTrue(mProgressBar.getInterpolator() instanceof AccelerateInterpolator);
    357     }
    358 
    359     @UiThreadTest
    360     @Test
    361     public void testSetVisibility() {
    362         // set visibility
    363         // normal value
    364         int visibility = View.VISIBLE;
    365         mProgressBarHorizontal.setVisibility(visibility);
    366         assertEquals(visibility, mProgressBarHorizontal.getVisibility());
    367 
    368         visibility = View.GONE;
    369         mProgressBarHorizontal.setVisibility(visibility);
    370         assertEquals(visibility, mProgressBarHorizontal.getVisibility());
    371 
    372         // exceptional value
    373         visibility = 0xfffffff5; // -11
    374         int mask = 0x0000000C; // View.VISIBILITY_MASK
    375         int expected = (mProgressBarHorizontal.getVisibility() & ~mask) | (visibility & mask);
    376         mProgressBarHorizontal.setVisibility(visibility);
    377         assertEquals(expected, mProgressBarHorizontal.getVisibility());
    378 
    379         visibility = 0x7fffffff; // Integer.MAX_VALUE;
    380         expected = (mProgressBarHorizontal.getVisibility() & ~mask) | (visibility & mask);
    381         mProgressBarHorizontal.setVisibility(Integer.MAX_VALUE);
    382         assertEquals(expected, mProgressBarHorizontal.getVisibility());
    383     }
    384 
    385     @UiThreadTest
    386     @Test
    387     public void testInvalidateDrawable() {
    388         ProgressBar mockProgressBar = spy(new ProgressBar(mActivity));
    389 
    390         Drawable mockDrawable1 = spy(new ColorDrawable(Color.RED));
    391         Drawable mockDrawable2 = spy(new ColorDrawable(Color.GREEN));
    392         mockProgressBar.setBackgroundDrawable(mockDrawable1);
    393 
    394         mockProgressBar.invalidateDrawable(mockDrawable1);
    395         verify(mockProgressBar, atLeastOnce()).invalidate(anyInt(), anyInt(), anyInt(), anyInt());
    396 
    397         reset(mockProgressBar);
    398         mockProgressBar.invalidateDrawable(mockDrawable2);
    399         verify(mockProgressBar, never()).invalidate(anyInt(), anyInt(), anyInt(), anyInt());
    400 
    401         mockProgressBar.setIndeterminateDrawable(mockDrawable1);
    402         mockProgressBar.setProgressDrawable(mockDrawable2);
    403     }
    404 
    405     @UiThreadTest
    406     @Test
    407     public void testPostInvalidate() {
    408         mProgressBarHorizontal.postInvalidate();
    409     }
    410 
    411     @UiThreadTest
    412     @Test
    413     public void testAccessMax() {
    414         // set Progress
    415         int progress = 10;
    416         mProgressBarHorizontal.setProgress(progress);
    417 
    418         // normal value
    419         int max = progress + 1;
    420         mProgressBarHorizontal.setMax(max);
    421         assertEquals(max, mProgressBarHorizontal.getMax());
    422         assertEquals(progress, mProgressBarHorizontal.getProgress());
    423 
    424         max = progress - 1;
    425         mProgressBarHorizontal.setMax(max);
    426         assertEquals(max, mProgressBarHorizontal.getMax());
    427         assertEquals(max, mProgressBarHorizontal.getProgress());
    428 
    429         // exceptional values
    430         mProgressBarHorizontal.setMax(-1);
    431         assertEquals(0, mProgressBarHorizontal.getMax());
    432         assertEquals(0, mProgressBarHorizontal.getProgress());
    433 
    434         mProgressBarHorizontal.setMax(Integer.MAX_VALUE);
    435         assertEquals(Integer.MAX_VALUE, mProgressBarHorizontal.getMax());
    436         assertEquals(0, mProgressBarHorizontal.getProgress());
    437     }
    438 
    439     @UiThreadTest
    440     @Test
    441     public void testProgressTint() {
    442         ProgressBar tintedProgressBar = (ProgressBar) mActivity.findViewById(R.id.progress_tint);
    443 
    444         assertEquals("Progress tint inflated correctly",
    445                 Color.WHITE, tintedProgressBar.getProgressTintList().getDefaultColor());
    446         assertEquals("Progress tint mode inflated correctly",
    447                 PorterDuff.Mode.SRC_OVER, tintedProgressBar.getProgressTintMode());
    448 
    449         assertEquals("Progress background tint inflated correctly",
    450                 Color.WHITE, tintedProgressBar.getProgressBackgroundTintList().getDefaultColor());
    451         assertEquals("Progress background tint mode inflated correctly",
    452                 PorterDuff.Mode.SRC_OVER, tintedProgressBar.getProgressBackgroundTintMode());
    453 
    454         assertEquals("Secondary progress tint inflated correctly",
    455                 Color.WHITE, tintedProgressBar.getSecondaryProgressTintList().getDefaultColor());
    456         assertEquals("Secondary progress tint mode inflated correctly",
    457                 PorterDuff.Mode.SRC_OVER, tintedProgressBar.getSecondaryProgressTintMode());
    458 
    459         Drawable mockProgressDrawable = spy(new ColorDrawable(Color.BLACK));
    460 
    461         mProgressBar.setProgressDrawable(mockProgressDrawable);
    462         // No progress tint applied by default
    463         verify(mockProgressDrawable, never()).setTintList(any(ColorStateList.class));
    464 
    465         mProgressBar.setProgressBackgroundTintList(ColorStateList.valueOf(Color.WHITE));
    466         // Progress background tint not applied when layer missing
    467         verify(mockProgressDrawable, never()).setTintList(any(ColorStateList.class));
    468 
    469         mProgressBar.setSecondaryProgressTintList(ColorStateList.valueOf(Color.WHITE));
    470         // Secondary progress tint not applied when layer missing
    471         verify(mockProgressDrawable, never()).setTintList(any(ColorStateList.class));
    472 
    473         mProgressBar.setProgressTintList(ColorStateList.valueOf(Color.WHITE));
    474         // Progress tint applied when setProgressTintList() called after setProgress()
    475         verify(mockProgressDrawable, times(1)).setTintList(TestUtils.colorStateListOf(Color.WHITE));
    476 
    477         mProgressBar.setProgressBackgroundTintMode(PorterDuff.Mode.DST_OVER);
    478         assertEquals(PorterDuff.Mode.DST_OVER, mProgressBar.getProgressBackgroundTintMode());
    479 
    480         mProgressBar.setSecondaryProgressTintMode(PorterDuff.Mode.DST_IN);
    481         assertEquals(PorterDuff.Mode.DST_IN, mProgressBar.getSecondaryProgressTintMode());
    482 
    483         mProgressBar.setProgressTintMode(PorterDuff.Mode.DST_ATOP);
    484         assertEquals(PorterDuff.Mode.DST_ATOP, mProgressBar.getProgressTintMode());
    485 
    486         reset(mockProgressDrawable);
    487         mProgressBar.setProgressDrawable(null);
    488         mProgressBar.setProgressDrawable(mockProgressDrawable);
    489         // Progress tint applied when setProgressTintList() called before setProgress()
    490         verify(mockProgressDrawable, times(1)).setTintList(TestUtils.colorStateListOf(Color.WHITE));
    491     }
    492 
    493     @UiThreadTest
    494     @Test
    495     public void testProgressTintBlendMode() {
    496         ProgressBar tintedProgressBar = (ProgressBar) mActivity.findViewById(R.id.progress_tint);
    497 
    498         assertEquals("Progress tint inflated correctly",
    499                 Color.WHITE, tintedProgressBar.getProgressTintList().getDefaultColor());
    500         assertEquals("Progress tint mode inflated correctly",
    501                 BlendMode.SRC_OVER, tintedProgressBar.getProgressTintBlendMode());
    502 
    503         assertEquals("Progress background tint inflated correctly",
    504                 Color.WHITE, tintedProgressBar.getProgressBackgroundTintList().getDefaultColor());
    505         assertEquals("Progress background tint mode inflated correctly",
    506                 BlendMode.SRC_OVER, tintedProgressBar.getProgressBackgroundTintBlendMode());
    507 
    508         assertEquals("Secondary progress tint inflated correctly",
    509                 Color.WHITE, tintedProgressBar.getSecondaryProgressTintList().getDefaultColor());
    510         assertEquals("Secondary progress tint mode inflated correctly",
    511                 BlendMode.SRC_OVER, tintedProgressBar.getSecondaryProgressTintBlendMode());
    512 
    513         Drawable mockProgressDrawable = spy(new ColorDrawable(Color.BLACK));
    514 
    515         mProgressBar.setProgressDrawable(mockProgressDrawable);
    516         // No progress tint applied by default
    517         verify(mockProgressDrawable, never()).setTintList(any(ColorStateList.class));
    518 
    519         mProgressBar.setProgressBackgroundTintList(ColorStateList.valueOf(Color.WHITE));
    520         // Progress background tint not applied when layer missing
    521         verify(mockProgressDrawable, never()).setTintList(any(ColorStateList.class));
    522 
    523         mProgressBar.setSecondaryProgressTintList(ColorStateList.valueOf(Color.WHITE));
    524         // Secondary progress tint not applied when layer missing
    525         verify(mockProgressDrawable, never()).setTintList(any(ColorStateList.class));
    526 
    527         mProgressBar.setProgressTintList(ColorStateList.valueOf(Color.WHITE));
    528         // Progress tint applied when setProgressTintList() called after setProgress()
    529         verify(mockProgressDrawable, times(1)).setTintList(TestUtils.colorStateListOf(Color.WHITE));
    530 
    531         mProgressBar.setProgressBackgroundTintBlendMode(BlendMode.DST_OVER);
    532         assertEquals(BlendMode.DST_OVER, mProgressBar.getProgressBackgroundTintBlendMode());
    533 
    534         mProgressBar.setSecondaryProgressTintBlendMode(BlendMode.DST_IN);
    535         assertEquals(BlendMode.DST_IN, mProgressBar.getSecondaryProgressTintBlendMode());
    536 
    537         mProgressBar.setProgressTintBlendMode(BlendMode.DST_ATOP);
    538         assertEquals(BlendMode.DST_ATOP, mProgressBar.getProgressTintBlendMode());
    539 
    540         reset(mockProgressDrawable);
    541         mProgressBar.setProgressDrawable(null);
    542         mProgressBar.setProgressDrawable(mockProgressDrawable);
    543         // Progress tint applied when setProgressTintList() called before setProgress()
    544         verify(mockProgressDrawable, times(1)).setTintList(TestUtils.colorStateListOf(Color.WHITE));
    545     }
    546 
    547     @UiThreadTest
    548     @Test
    549     public void testIndeterminateTint() {
    550         ProgressBar tintedProgressBar =
    551                 (ProgressBar) mActivity.findViewById(R.id.indeterminate_tint);
    552 
    553         assertEquals("Indeterminate tint inflated correctly",
    554                 Color.WHITE, tintedProgressBar.getIndeterminateTintList().getDefaultColor());
    555         assertEquals("Indeterminate tint mode inflated correctly",
    556                 PorterDuff.Mode.SRC_OVER, tintedProgressBar.getIndeterminateTintMode());
    557 
    558         Drawable mockIndeterminateDrawable = spy(new ColorDrawable(Color.MAGENTA));
    559 
    560         mProgressBar.setIndeterminateDrawable(mockIndeterminateDrawable);
    561         // No indeterminate tint applied by default
    562         verify(mockIndeterminateDrawable, never()).setTintList(any(ColorStateList.class));
    563 
    564         mProgressBar.setIndeterminateTintList(ColorStateList.valueOf(Color.RED));
    565         // Indeterminate tint applied when setIndeterminateTintList() called after
    566         // setIndeterminate()
    567         verify(mockIndeterminateDrawable, times(1)).setTintList(
    568                 TestUtils.colorStateListOf(Color.RED));
    569 
    570         mProgressBar.setIndeterminateTintMode(PorterDuff.Mode.LIGHTEN);
    571         assertEquals(PorterDuff.Mode.LIGHTEN, mProgressBar.getIndeterminateTintMode());
    572 
    573         reset(mockIndeterminateDrawable);
    574         mProgressBar.setIndeterminateDrawable(null);
    575         mProgressBar.setIndeterminateDrawable(mockIndeterminateDrawable);
    576         // Indeterminate tint applied when setIndeterminateTintList() called before
    577         // setIndeterminate()
    578         verify(mockIndeterminateDrawable, times(1)).setTintList(
    579                 TestUtils.colorStateListOf(Color.RED));
    580     }
    581 
    582     @UiThreadTest
    583     @Test
    584     public void testIndeterminateTintBlendMode() {
    585         ProgressBar tintedProgressBar =
    586                 (ProgressBar) mActivity.findViewById(R.id.indeterminate_tint);
    587 
    588         assertEquals("Indeterminate tint inflated correctly",
    589                 Color.WHITE, tintedProgressBar.getIndeterminateTintList().getDefaultColor());
    590         assertEquals("Indeterminate tint mode inflated correctly",
    591                 BlendMode.SRC_OVER, tintedProgressBar.getIndeterminateTintBlendMode());
    592 
    593         Drawable mockIndeterminateDrawable = spy(new ColorDrawable(Color.MAGENTA));
    594 
    595         mProgressBar.setIndeterminateDrawable(mockIndeterminateDrawable);
    596         // No indeterminate tint applied by default
    597         verify(mockIndeterminateDrawable, never()).setTintList(any(ColorStateList.class));
    598 
    599         mProgressBar.setIndeterminateTintList(ColorStateList.valueOf(Color.RED));
    600         // Indeterminate tint applied when setIndeterminateTintList() called after
    601         // setIndeterminate()
    602         verify(mockIndeterminateDrawable, times(1)).setTintList(
    603                 TestUtils.colorStateListOf(Color.RED));
    604 
    605         mProgressBar.setIndeterminateTintBlendMode(BlendMode.LIGHTEN);
    606         assertEquals(BlendMode.LIGHTEN, mProgressBar.getIndeterminateTintBlendMode());
    607 
    608         reset(mockIndeterminateDrawable);
    609         mProgressBar.setIndeterminateDrawable(null);
    610         mProgressBar.setIndeterminateDrawable(mockIndeterminateDrawable);
    611         // Indeterminate tint applied when setIndeterminateTintList() called before
    612         // setIndeterminate()
    613         verify(mockIndeterminateDrawable, times(1)).setTintList(
    614                 TestUtils.colorStateListOf(Color.RED));
    615     }
    616 
    617     @UiThreadTest
    618     @Test
    619     public void testVerifyDrawable() {
    620         MockProgressBar mockProgressBar =
    621                 (MockProgressBar) mActivity.findViewById(R.id.progress_custom);
    622 
    623         Drawable d1 = mActivity.getDrawable(R.drawable.blue);
    624         Drawable d2 = mActivity.getDrawable(R.drawable.red);
    625         Drawable d3 = mActivity.getDrawable(R.drawable.yellow);
    626 
    627         mockProgressBar.setBackgroundDrawable(d1);
    628         assertTrue(mockProgressBar.verifyDrawable(d1));
    629         assertFalse(mockProgressBar.verifyDrawable(d2));
    630         assertFalse(mockProgressBar.verifyDrawable(d3));
    631 
    632         mockProgressBar.setIndeterminateDrawable(d2);
    633         assertTrue(mockProgressBar.verifyDrawable(d1));
    634         assertTrue(mockProgressBar.verifyDrawable(d2));
    635         assertFalse(mockProgressBar.verifyDrawable(d3));
    636 
    637         mockProgressBar.setProgressDrawable(d3);
    638         assertTrue(mockProgressBar.verifyDrawable(d1));
    639         assertTrue(mockProgressBar.verifyDrawable(d2));
    640         assertTrue(mockProgressBar.verifyDrawable(d3));
    641     }
    642 
    643     @UiThreadTest
    644     @Test
    645     public void testOnSaveAndRestoreInstanceState() {
    646         int oldProgress = 1;
    647         int oldSecondaryProgress = mProgressBarHorizontal.getMax() - 1;
    648         mProgressBarHorizontal.setProgress(oldProgress);
    649         mProgressBarHorizontal.setSecondaryProgress(oldSecondaryProgress);
    650         assertEquals(oldProgress, mProgressBarHorizontal.getProgress());
    651         assertEquals(oldSecondaryProgress, mProgressBarHorizontal.getSecondaryProgress());
    652 
    653         Parcelable state = mProgressBarHorizontal.onSaveInstanceState();
    654 
    655         int newProgress = 2;
    656         int newSecondaryProgress = mProgressBarHorizontal.getMax() - 2;
    657         mProgressBarHorizontal.setProgress(newProgress);
    658         mProgressBarHorizontal.setSecondaryProgress(newSecondaryProgress);
    659         assertEquals(newProgress, mProgressBarHorizontal.getProgress());
    660         assertEquals(newSecondaryProgress, mProgressBarHorizontal.getSecondaryProgress());
    661 
    662         mProgressBarHorizontal.onRestoreInstanceState(state);
    663         assertEquals(oldProgress, mProgressBarHorizontal.getProgress());
    664         assertEquals(oldSecondaryProgress, mProgressBarHorizontal.getSecondaryProgress());
    665     }
    666 
    667     @UiThreadTest
    668     @Test
    669     public void testGetAndSetMinWidth() {
    670         final int minWidth = 20;
    671         mProgressBar.setMinWidth(minWidth);
    672         assertEquals(minWidth, mProgressBar.getMinWidth());
    673     }
    674 
    675     @UiThreadTest
    676     @Test
    677     public void testGetAndSetMaxWidth() {
    678         final int maxWidth = 20;
    679         mProgressBar.setMaxWidth(maxWidth);
    680         assertEquals(maxWidth, mProgressBar.getMaxWidth());
    681     }
    682 
    683     @UiThreadTest
    684     @Test
    685     public void testGetAndSetMinHeight() {
    686         final int minHeight = 20;
    687         mProgressBar.setMinHeight(minHeight);
    688         assertEquals(minHeight, mProgressBar.getMinHeight());
    689     }
    690 
    691     @UiThreadTest
    692     @Test
    693     public void testGetAndSetMaxHeight() {
    694         final int maxHeight = 20;
    695         mProgressBar.setMaxHeight(maxHeight);
    696         assertEquals(maxHeight, mProgressBar.getMaxHeight());
    697     }
    698 
    699     /*
    700      * Mock class for ProgressBar to test protected methods
    701      */
    702     public static class MockProgressBar extends ProgressBar {
    703         public MockProgressBar(Context context) {
    704             super(context);
    705         }
    706 
    707         public MockProgressBar(Context context, AttributeSet attrs) {
    708             super(context, attrs);
    709         }
    710 
    711         @Override
    712         protected boolean verifyDrawable(Drawable who) {
    713             return super.verifyDrawable(who);
    714         }
    715     }
    716 }
    717