| /* |
| * Copyright (C) 2008 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.widget.cts; |
| |
| import static org.junit.Assert.assertArrayEquals; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertNotSame; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertSame; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| import static org.mockito.Matchers.any; |
| import static org.mockito.Matchers.anyInt; |
| import static org.mockito.Mockito.atLeastOnce; |
| import static org.mockito.Mockito.never; |
| import static org.mockito.Mockito.spy; |
| import static org.mockito.Mockito.times; |
| import static org.mockito.Mockito.verify; |
| |
| import android.app.Activity; |
| import android.content.Context; |
| import android.content.res.ColorStateList; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.graphics.Canvas; |
| import android.graphics.Color; |
| import android.graphics.ColorFilter; |
| import android.graphics.Matrix; |
| import android.graphics.PorterDuff; |
| import android.graphics.drawable.BitmapDrawable; |
| import android.graphics.drawable.ColorDrawable; |
| import android.graphics.drawable.Drawable; |
| import android.graphics.drawable.Icon; |
| import android.graphics.drawable.PaintDrawable; |
| import android.net.Uri; |
| import android.util.AttributeSet; |
| import android.util.Xml; |
| import android.widget.ImageView; |
| import android.widget.ImageView.ScaleType; |
| import android.widget.cts.util.TestUtils; |
| |
| import androidx.test.annotation.UiThreadTest; |
| import androidx.test.filters.MediumTest; |
| import androidx.test.rule.ActivityTestRule; |
| import androidx.test.runner.AndroidJUnit4; |
| |
| import com.android.compatibility.common.util.WidgetTestUtils; |
| |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.xmlpull.v1.XmlPullParser; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| |
| /** |
| * Test {@link ImageView}. |
| */ |
| @MediumTest |
| @RunWith(AndroidJUnit4.class) |
| public class ImageViewTest { |
| private Activity mActivity; |
| private ImageView mImageViewRegular; |
| |
| @Rule |
| public ActivityTestRule<ImageViewCtsActivity> mActivityRule = |
| new ActivityTestRule<>(ImageViewCtsActivity.class); |
| |
| @Before |
| public void setup() { |
| mActivity = mActivityRule.getActivity(); |
| mImageViewRegular = (ImageView) mActivity.findViewById(R.id.imageview_regular); |
| } |
| |
| /** |
| * Find the ImageView specified by id. |
| * |
| * @param id the id |
| * @return the ImageView |
| */ |
| private ImageView findImageViewById(int id) { |
| return (ImageView) mActivity.findViewById(id); |
| } |
| |
| private void createSampleImage(File imagefile, int resid) { |
| try (InputStream source = mActivity.getResources().openRawResource(resid); |
| OutputStream target = new FileOutputStream(imagefile)) { |
| byte[] buffer = new byte[1024]; |
| for (int len = source.read(buffer); len > 0; len = source.read(buffer)) { |
| target.write(buffer, 0, len); |
| } |
| } catch (IOException e) { |
| fail(e.getMessage()); |
| } |
| } |
| |
| @Test |
| public void testConstructor() { |
| new ImageView(mActivity); |
| |
| new ImageView(mActivity, null); |
| |
| new ImageView(mActivity, null, 0); |
| |
| new ImageView(mActivity, null, 0, 0); |
| |
| XmlPullParser parser = mActivity.getResources().getXml(R.layout.imageview_layout); |
| AttributeSet attrs = Xml.asAttributeSet(parser); |
| new ImageView(mActivity, attrs); |
| new ImageView(mActivity, attrs, 0); |
| } |
| |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorNullContext1() { |
| new ImageView(null); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorNullContext2() { |
| new ImageView(null, null); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testConstructorNullContext3() { |
| new ImageView(null, null, -1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testInvalidateDrawable() { |
| mImageViewRegular.invalidateDrawable(null); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetAdjustViewBounds() { |
| mImageViewRegular.setScaleType(ScaleType.FIT_XY); |
| |
| mImageViewRegular.setAdjustViewBounds(false); |
| assertFalse(mImageViewRegular.getAdjustViewBounds()); |
| assertEquals(ScaleType.FIT_XY, mImageViewRegular.getScaleType()); |
| |
| mImageViewRegular.setAdjustViewBounds(true); |
| assertTrue(mImageViewRegular.getAdjustViewBounds()); |
| assertEquals(ScaleType.FIT_CENTER, mImageViewRegular.getScaleType()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetMaxWidth() { |
| mImageViewRegular.setMaxWidth(120); |
| mImageViewRegular.setMaxWidth(-1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetMaxHeight() { |
| mImageViewRegular.setMaxHeight(120); |
| mImageViewRegular.setMaxHeight(-1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testGetDrawable() { |
| final PaintDrawable drawable1 = new PaintDrawable(); |
| final PaintDrawable drawable2 = new PaintDrawable(); |
| |
| assertNull(mImageViewRegular.getDrawable()); |
| |
| mImageViewRegular.setImageDrawable(drawable1); |
| assertEquals(drawable1, mImageViewRegular.getDrawable()); |
| assertNotSame(drawable2, mImageViewRegular.getDrawable()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetImageIcon() { |
| mImageViewRegular.setImageIcon(null); |
| assertNull(mImageViewRegular.getDrawable()); |
| |
| Icon icon = Icon.createWithResource(mActivity, R.drawable.testimage); |
| mImageViewRegular.setImageIcon(icon); |
| assertTrue(mImageViewRegular.isLayoutRequested()); |
| assertNotNull(mImageViewRegular.getDrawable()); |
| Drawable drawable = mActivity.getDrawable(R.drawable.testimage); |
| BitmapDrawable testimageBitmap = (BitmapDrawable) drawable; |
| Drawable imageViewDrawable = mImageViewRegular.getDrawable(); |
| BitmapDrawable imageViewBitmap = (BitmapDrawable) imageViewDrawable; |
| WidgetTestUtils.assertEquals(testimageBitmap.getBitmap(), imageViewBitmap.getBitmap()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetImageResource() { |
| mImageViewRegular.setImageResource(-1); |
| assertNull(mImageViewRegular.getDrawable()); |
| |
| mImageViewRegular.setImageResource(R.drawable.testimage); |
| assertTrue(mImageViewRegular.isLayoutRequested()); |
| assertNotNull(mImageViewRegular.getDrawable()); |
| Drawable drawable = mActivity.getDrawable(R.drawable.testimage); |
| BitmapDrawable testimageBitmap = (BitmapDrawable) drawable; |
| Drawable imageViewDrawable = mImageViewRegular.getDrawable(); |
| BitmapDrawable imageViewBitmap = (BitmapDrawable) imageViewDrawable; |
| WidgetTestUtils.assertEquals(testimageBitmap.getBitmap(), imageViewBitmap.getBitmap()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetImageURI() { |
| mImageViewRegular.setImageURI(null); |
| assertNull(mImageViewRegular.getDrawable()); |
| |
| File dbDir = mActivity.getDir("tests", Context.MODE_PRIVATE); |
| File imagefile = new File(dbDir, "tempimage.jpg"); |
| if (imagefile.exists()) { |
| imagefile.delete(); |
| } |
| createSampleImage(imagefile, R.raw.testimage); |
| final String path = imagefile.getPath(); |
| mImageViewRegular.setImageURI(Uri.parse(path)); |
| assertTrue(mImageViewRegular.isLayoutRequested()); |
| assertNotNull(mImageViewRegular.getDrawable()); |
| |
| Drawable imageViewDrawable = mImageViewRegular.getDrawable(); |
| BitmapDrawable imageViewBitmap = (BitmapDrawable) imageViewDrawable; |
| Bitmap.Config viewConfig = imageViewBitmap.getBitmap().getConfig(); |
| Bitmap testimageBitmap = WidgetTestUtils.getUnscaledAndDitheredBitmap( |
| mActivity.getResources(), R.raw.testimage, viewConfig); |
| |
| WidgetTestUtils.assertEquals(testimageBitmap, imageViewBitmap.getBitmap()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetImageDrawable() { |
| mImageViewRegular.setImageDrawable(null); |
| assertNull(mImageViewRegular.getDrawable()); |
| |
| final Drawable drawable = mActivity.getDrawable(R.drawable.testimage); |
| mImageViewRegular.setImageDrawable(drawable); |
| assertTrue(mImageViewRegular.isLayoutRequested()); |
| assertNotNull(mImageViewRegular.getDrawable()); |
| BitmapDrawable testimageBitmap = (BitmapDrawable) drawable; |
| Drawable imageViewDrawable = mImageViewRegular.getDrawable(); |
| BitmapDrawable imageViewBitmap = (BitmapDrawable) imageViewDrawable; |
| WidgetTestUtils.assertEquals(testimageBitmap.getBitmap(), imageViewBitmap.getBitmap()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetImageBitmap() { |
| mImageViewRegular.setImageBitmap(null); |
| // A BitmapDrawable is always created for the ImageView. |
| assertNotNull(mImageViewRegular.getDrawable()); |
| |
| final Bitmap bitmap = |
| BitmapFactory.decodeResource(mActivity.getResources(), R.drawable.testimage); |
| mImageViewRegular.setImageBitmap(bitmap); |
| assertTrue(mImageViewRegular.isLayoutRequested()); |
| assertNotNull(mImageViewRegular.getDrawable()); |
| Drawable imageViewDrawable = mImageViewRegular.getDrawable(); |
| BitmapDrawable imageViewBitmap = (BitmapDrawable) imageViewDrawable; |
| WidgetTestUtils.assertEquals(bitmap, imageViewBitmap.getBitmap()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetImageState() { |
| int[] state = new int[8]; |
| mImageViewRegular.setImageState(state, false); |
| assertSame(state, mImageViewRegular.onCreateDrawableState(0)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetSelected() { |
| assertFalse(mImageViewRegular.isSelected()); |
| |
| mImageViewRegular.setSelected(true); |
| assertTrue(mImageViewRegular.isSelected()); |
| |
| mImageViewRegular.setSelected(false); |
| assertFalse(mImageViewRegular.isSelected()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetImageLevel() { |
| PaintDrawable drawable = new PaintDrawable(); |
| drawable.setLevel(0); |
| |
| mImageViewRegular.setImageDrawable(drawable); |
| mImageViewRegular.setImageLevel(1); |
| assertEquals(1, drawable.getLevel()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessScaleType() { |
| assertNotNull(mImageViewRegular.getScaleType()); |
| |
| mImageViewRegular.setScaleType(ImageView.ScaleType.CENTER); |
| assertEquals(ImageView.ScaleType.CENTER, mImageViewRegular.getScaleType()); |
| |
| mImageViewRegular.setScaleType(ImageView.ScaleType.MATRIX); |
| assertEquals(ImageView.ScaleType.MATRIX, mImageViewRegular.getScaleType()); |
| |
| mImageViewRegular.setScaleType(ImageView.ScaleType.FIT_START); |
| assertEquals(ImageView.ScaleType.FIT_START, mImageViewRegular.getScaleType()); |
| |
| mImageViewRegular.setScaleType(ImageView.ScaleType.FIT_END); |
| assertEquals(ImageView.ScaleType.FIT_END, mImageViewRegular.getScaleType()); |
| |
| mImageViewRegular.setScaleType(ImageView.ScaleType.CENTER_CROP); |
| assertEquals(ImageView.ScaleType.CENTER_CROP, mImageViewRegular.getScaleType()); |
| |
| mImageViewRegular.setScaleType(ImageView.ScaleType.CENTER_INSIDE); |
| assertEquals(ImageView.ScaleType.CENTER_INSIDE, mImageViewRegular.getScaleType()); |
| } |
| |
| @UiThreadTest |
| @Test(expected=NullPointerException.class) |
| public void testSetNullScaleType() { |
| mImageViewRegular.setScaleType(null); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessImageMatrix() { |
| mImageViewRegular.setImageMatrix(null); |
| assertNotNull(mImageViewRegular.getImageMatrix()); |
| |
| final Matrix matrix = new Matrix(); |
| mImageViewRegular.setImageMatrix(matrix); |
| assertEquals(matrix, mImageViewRegular.getImageMatrix()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAccessBaseline() { |
| mImageViewRegular.setImageDrawable(null); |
| assertNull(mImageViewRegular.getDrawable()); |
| |
| final Drawable drawable = mActivity.getDrawable(R.drawable.testimage); |
| mImageViewRegular.setImageDrawable(drawable); |
| |
| assertEquals(-1, mImageViewRegular.getBaseline()); |
| |
| mImageViewRegular.setBaseline(50); |
| assertEquals(50, mImageViewRegular.getBaseline()); |
| |
| mImageViewRegular.setBaselineAlignBottom(true); |
| assertTrue(mImageViewRegular.getBaselineAlignBottom()); |
| assertEquals(mImageViewRegular.getMeasuredHeight(), mImageViewRegular.getBaseline()); |
| |
| mImageViewRegular.setBaselineAlignBottom(false); |
| assertFalse(mImageViewRegular.getBaselineAlignBottom()); |
| assertEquals(50, mImageViewRegular.getBaseline()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetColorFilter1() { |
| final Drawable drawable = mActivity.getDrawable(R.drawable.testimage); |
| mImageViewRegular.setImageDrawable(drawable); |
| |
| mImageViewRegular.setColorFilter(null); |
| assertNull(drawable.getColorFilter()); |
| |
| mImageViewRegular.setColorFilter(0, PorterDuff.Mode.CLEAR); |
| assertNotNull(drawable.getColorFilter()); |
| assertNotNull(mImageViewRegular.getColorFilter()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testClearColorFilter() { |
| final Drawable drawable = mActivity.getDrawable(R.drawable.testimage); |
| mImageViewRegular.setImageDrawable(drawable); |
| |
| ColorFilter cf = new ColorFilter(); |
| mImageViewRegular.setColorFilter(cf); |
| |
| mImageViewRegular.clearColorFilter(); |
| assertNull(drawable.getColorFilter()); |
| assertNull(mImageViewRegular.getColorFilter()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testSetColorFilter2() { |
| final Drawable drawable = mActivity.getDrawable(R.drawable.testimage); |
| mImageViewRegular.setImageDrawable(drawable); |
| |
| mImageViewRegular.setColorFilter(null); |
| assertNull(drawable.getColorFilter()); |
| assertNull(mImageViewRegular.getColorFilter()); |
| |
| ColorFilter cf = new ColorFilter(); |
| mImageViewRegular.setColorFilter(cf); |
| assertSame(cf, drawable.getColorFilter()); |
| assertSame(cf, mImageViewRegular.getColorFilter()); |
| } |
| |
| @Test |
| public void testDrawableStateChanged() { |
| MockImageView imageView = spy(new MockImageView(mActivity)); |
| Drawable selectorDrawable = mActivity.getDrawable(R.drawable.statelistdrawable); |
| imageView.setImageDrawable(selectorDrawable); |
| |
| // We shouldn't have been called on state change yet |
| verify(imageView, never()).drawableStateChanged(); |
| // Mark image view as selected. Since our selector drawable has an "entry" for selected |
| // state, that should cause a call to drawableStateChanged() |
| imageView.setSelected(true); |
| // Test that our image view has indeed called its own drawableStateChanged() |
| verify(imageView, times(1)).drawableStateChanged(); |
| // And verify that image view's state matches that of our drawable |
| assertArrayEquals(imageView.getDrawableState(), selectorDrawable.getState()); |
| } |
| |
| @Test |
| public void testOnCreateDrawableState() { |
| MockImageView mockImageView = new MockImageView(mActivity); |
| |
| assertArrayEquals(MockImageView.getEnabledStateSet(), |
| mockImageView.onCreateDrawableState(0)); |
| |
| int[] expected = new int[]{1, 2, 3}; |
| mockImageView.setImageState(expected, false); |
| assertArrayEquals(expected, mockImageView.onCreateDrawableState(1)); |
| |
| mockImageView.setImageState(expected, true); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testOnCreateDrawableStateInvalid() { |
| MockImageView mockImageView = (MockImageView) findImageViewById(R.id.imageview_custom); |
| mockImageView.setImageState(new int[] {1, 2, 3}, true); |
| mockImageView.onCreateDrawableState(-1); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testOnDraw() { |
| MockImageView mockImageView = (MockImageView) findImageViewById(R.id.imageview_custom); |
| |
| Drawable drawable = spy(mActivity.getDrawable(R.drawable.icon_red)); |
| mockImageView.setImageDrawable(drawable); |
| mockImageView.onDraw(new Canvas()); |
| |
| verify(drawable, atLeastOnce()).draw(any(Canvas.class)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testOnMeasure() { |
| mImageViewRegular.measure(200, 150); |
| assertTrue(mImageViewRegular.getMeasuredWidth() <= 200); |
| assertTrue(mImageViewRegular.getMeasuredHeight() <= 150); |
| } |
| |
| @Test |
| public void testSetFrame() { |
| MockImageView mockImageView = spy(new MockImageView(mActivity)); |
| verify(mockImageView, never()).onSizeChanged(anyInt(), anyInt(), anyInt(), anyInt()); |
| |
| assertTrue(mockImageView.setFrame(5, 10, 100, 200)); |
| assertEquals(5, mockImageView.getLeft()); |
| assertEquals(10, mockImageView.getTop()); |
| assertEquals(100, mockImageView.getRight()); |
| assertEquals(200, mockImageView.getBottom()); |
| verify(mockImageView, times(1)).onSizeChanged(95, 190, 0, 0); |
| |
| assertFalse(mockImageView.setFrame(5, 10, 100, 200)); |
| // Verify that there were no more calls to onSizeChanged (since the new frame is the |
| // same frame as we had before). |
| verify(mockImageView, times(1)).onSizeChanged(anyInt(), anyInt(), anyInt(), anyInt()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testVerifyDrawable() { |
| MockImageView mockImageView = (MockImageView) findImageViewById(R.id.imageview_custom); |
| |
| Drawable drawable = new ColorDrawable(0xFFFF0000); |
| mockImageView.setImageDrawable(drawable); |
| Drawable backgroundDrawable = new ColorDrawable(0xFF0000FF); |
| mockImageView.setBackgroundDrawable(backgroundDrawable); |
| |
| assertFalse(mockImageView.verifyDrawable(new ColorDrawable(0xFF00FF00))); |
| assertTrue(mockImageView.verifyDrawable(drawable)); |
| assertTrue(mockImageView.verifyDrawable(backgroundDrawable)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImageTintBasics() { |
| ImageView imageViewTinted = (ImageView) mActivity.findViewById(R.id.imageview_tint); |
| |
| assertEquals("Image tint inflated correctly", |
| Color.WHITE, imageViewTinted.getImageTintList().getDefaultColor()); |
| assertEquals("Image tint mode inflated correctly", |
| PorterDuff.Mode.SRC_OVER, imageViewTinted.getImageTintMode()); |
| |
| imageViewTinted.setImageTintMode(PorterDuff.Mode.SRC_IN); |
| assertEquals(PorterDuff.Mode.SRC_IN, imageViewTinted.getImageTintMode()); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImageTintDrawableUpdates() { |
| Drawable drawable = spy(mActivity.getDrawable(R.drawable.icon_red)); |
| |
| mImageViewRegular.setImageDrawable(drawable); |
| // No image tint applied by default |
| verify(drawable, never()).setTintList(any(ColorStateList.class)); |
| |
| mImageViewRegular.setImageTintList(ColorStateList.valueOf(Color.WHITE)); |
| // Image tint applied when setImageTintList() called after setImageDrawable() |
| verify(drawable, times(1)).setTintList(any(ColorStateList.class)); |
| |
| mImageViewRegular.setImageDrawable(null); |
| mImageViewRegular.setImageDrawable(drawable); |
| // Image tint applied when setImageTintList() called before setImageDrawable() |
| verify(drawable, times(2)).setTintList(any(ColorStateList.class)); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImageTintVisuals() { |
| ImageView imageViewTinted = (ImageView) mActivity.findViewById( |
| R.id.imageview_tint_with_source); |
| |
| TestUtils.assertAllPixelsOfColor("All pixels should be white", imageViewTinted, |
| 0xFFFFFFFF, 1, false); |
| |
| // Use translucent white tint. Together with SRC_OVER mode (defined in XML) the end |
| // result should be a fully opaque image view with solid fill color in between red |
| // and white. |
| imageViewTinted.setImageTintList(ColorStateList.valueOf(0x80FFFFFF)); |
| TestUtils.assertAllPixelsOfColor("All pixels should be light red", imageViewTinted, |
| 0xFFFF8080, 1, false); |
| |
| // Switch to SRC_IN mode. This should completely ignore the original drawable set on |
| // the image view and use the last set tint color (50% alpha white). |
| imageViewTinted.setImageTintMode(PorterDuff.Mode.SRC_IN); |
| TestUtils.assertAllPixelsOfColor("All pixels should be 50% alpha white", imageViewTinted, |
| 0x80FFFFFF, 1, false); |
| |
| // Switch to DST mode. This should completely ignore the last set tint color and use the |
| // the original drawable set on the image view. |
| imageViewTinted.setImageTintMode(PorterDuff.Mode.DST); |
| TestUtils.assertAllPixelsOfColor("All pixels should be red", imageViewTinted, |
| 0xFFFF0000, 1, false); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testAlpha() { |
| mImageViewRegular.setImageResource(R.drawable.blue_fill); |
| |
| TestUtils.assertAllPixelsOfColor("All pixels should be blue", mImageViewRegular, |
| 0xFF0000FF, 1, false); |
| |
| mImageViewRegular.setAlpha(128); |
| TestUtils.assertAllPixelsOfColor("All pixels should be 50% alpha blue", mImageViewRegular, |
| 0x800000FF, 1, false); |
| |
| mImageViewRegular.setAlpha(0); |
| TestUtils.assertAllPixelsOfColor("All pixels should be transparent", mImageViewRegular, |
| 0x00000000, 1, false); |
| |
| mImageViewRegular.setAlpha(255); |
| TestUtils.assertAllPixelsOfColor("All pixels should be blue", mImageViewRegular, |
| 0xFF0000FF, 1, false); |
| } |
| |
| @UiThreadTest |
| @Test |
| public void testImageAlpha() { |
| mImageViewRegular.setImageResource(R.drawable.blue_fill); |
| |
| assertEquals(255, mImageViewRegular.getImageAlpha()); |
| TestUtils.assertAllPixelsOfColor("All pixels should be blue", mImageViewRegular, |
| 0xFF0000FF, 1, false); |
| |
| mImageViewRegular.setImageAlpha(128); |
| assertEquals(128, mImageViewRegular.getImageAlpha()); |
| TestUtils.assertAllPixelsOfColor("All pixels should be 50% alpha blue", mImageViewRegular, |
| 0x800000FF, 1, false); |
| |
| mImageViewRegular.setImageAlpha(0); |
| assertEquals(0, mImageViewRegular.getImageAlpha()); |
| TestUtils.assertAllPixelsOfColor("All pixels should be transparent", mImageViewRegular, |
| 0x00000000, 1, false); |
| |
| mImageViewRegular.setImageAlpha(255); |
| assertEquals(255, mImageViewRegular.getImageAlpha()); |
| TestUtils.assertAllPixelsOfColor("All pixels should be blue", mImageViewRegular, |
| 0xFF0000FF, 1, false); |
| } |
| |
| public static class MockImageView extends ImageView { |
| public MockImageView(Context context) { |
| super(context); |
| } |
| |
| public MockImageView(Context context, AttributeSet attrs) { |
| super(context, attrs); |
| } |
| |
| public MockImageView(Context context, AttributeSet attrs, int defStyle) { |
| super(context, attrs, defStyle); |
| } |
| |
| public static int[] getEnabledStateSet() { |
| return ENABLED_STATE_SET; |
| } |
| |
| @Override |
| protected void drawableStateChanged() { |
| super.drawableStateChanged(); |
| } |
| |
| @Override |
| protected void onDraw(Canvas canvas) { |
| super.onDraw(canvas); |
| } |
| |
| @Override |
| protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { |
| super.onMeasure(widthMeasureSpec, heightMeasureSpec); |
| } |
| |
| @Override |
| protected boolean onSetAlpha(int alpha) { |
| return super.onSetAlpha(alpha); |
| } |
| |
| @Override |
| protected boolean setFrame(int l, int t, int r, int b) { |
| return super.setFrame(l, t, r, b); |
| } |
| |
| @Override |
| protected boolean verifyDrawable(Drawable dr) { |
| return super.verifyDrawable(dr); |
| } |
| |
| protected void onSizeChanged(int w, int h, int oldw, int oldh) { |
| super.onSizeChanged(w, h, oldw, oldh); |
| } |
| } |
| } |
