| /* |
| * 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.graphics.cts; |
| |
| import static org.junit.Assert.assertArrayEquals; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNull; |
| import static org.junit.Assert.assertTrue; |
| import static org.junit.Assert.fail; |
| |
| import android.content.res.Resources; |
| import android.graphics.Bitmap; |
| import android.graphics.Bitmap.Config; |
| import android.graphics.BitmapFactory; |
| import android.graphics.BitmapShader; |
| import android.graphics.Canvas; |
| import android.graphics.Canvas.EdgeType; |
| import android.graphics.Canvas.VertexMode; |
| import android.graphics.Color; |
| import android.graphics.ComposeShader; |
| import android.graphics.DrawFilter; |
| import android.graphics.Matrix; |
| import android.graphics.Paint; |
| import android.graphics.Path; |
| import android.graphics.Path.Direction; |
| import android.graphics.Picture; |
| import android.graphics.PorterDuff.Mode; |
| import android.graphics.RadialGradient; |
| import android.graphics.Rect; |
| import android.graphics.RectF; |
| import android.graphics.Region.Op; |
| import android.graphics.Shader; |
| import android.text.SpannableString; |
| import android.text.SpannableStringBuilder; |
| import android.text.SpannedString; |
| import android.util.DisplayMetrics; |
| |
| import androidx.test.InstrumentationRegistry; |
| import androidx.test.filters.SmallTest; |
| import androidx.test.runner.AndroidJUnit4; |
| |
| import com.android.compatibility.common.util.ColorUtils; |
| |
| import org.junit.Assert; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| |
| @SmallTest |
| @RunWith(AndroidJUnit4.class) |
| public class CanvasTest { |
| private final static int PAINT_COLOR = 0xff00ff00; |
| private final static int BITMAP_WIDTH = 10; |
| private final static int BITMAP_HEIGHT = 28; |
| private final static int FLOAT_ARRAY_LEN = 9; |
| |
| // used for save related methods tests |
| private final float[] values1 = { |
| 1, 2, 3, 4, 5, 6, 7, 8, 9 |
| }; |
| |
| private final float[] values2 = { |
| 9, 8, 7, 6, 5, 4, 3, 2, 1 |
| }; |
| |
| private Paint mPaint; |
| private Canvas mCanvas; |
| private Bitmap mImmutableBitmap; |
| private Bitmap mMutableBitmap; |
| |
| @Before |
| public void setup() { |
| mPaint = new Paint(); |
| mPaint.setColor(PAINT_COLOR); |
| |
| final Resources res = InstrumentationRegistry.getTargetContext().getResources(); |
| BitmapFactory.Options opt = new BitmapFactory.Options(); |
| opt.inScaled = false; // bitmap will only be immutable if not scaled during load |
| mImmutableBitmap = BitmapFactory.decodeResource(res, R.drawable.start, opt); |
| assertFalse(mImmutableBitmap.isMutable()); |
| mMutableBitmap = Bitmap.createBitmap(BITMAP_WIDTH, BITMAP_HEIGHT, Config.ARGB_8888); |
| mCanvas = new Canvas(mMutableBitmap); |
| } |
| |
| @Test |
| public void testCanvas() { |
| new Canvas(); |
| |
| mMutableBitmap = Bitmap.createBitmap(BITMAP_WIDTH, BITMAP_HEIGHT, Config.ARGB_8888); |
| new Canvas(mMutableBitmap); |
| } |
| |
| @Test(expected=IllegalStateException.class) |
| public void testCanvasFromImmutableBitmap() { |
| // Should throw out IllegalStateException when creating Canvas with an ImmutableBitmap |
| new Canvas(mImmutableBitmap); |
| } |
| |
| @Test(expected=RuntimeException.class) |
| public void testCanvasFromRecycledBitmap() { |
| // Should throw out RuntimeException when creating Canvas with a MutableBitmap which |
| // is recycled |
| mMutableBitmap.recycle(); |
| new Canvas(mMutableBitmap); |
| } |
| |
| @Test(expected=IllegalStateException.class) |
| public void testSetBitmapToImmutableBitmap() { |
| // Should throw out IllegalStateException when setting an ImmutableBitmap to a Canvas |
| mCanvas.setBitmap(mImmutableBitmap); |
| } |
| |
| @Test(expected=RuntimeException.class) |
| public void testSetBitmapToRecycledBitmap() { |
| // Should throw out RuntimeException when setting Bitmap which is recycled to a Canvas |
| mMutableBitmap.recycle(); |
| mCanvas.setBitmap(mMutableBitmap); |
| } |
| |
| @Test |
| public void testSetBitmap() { |
| mMutableBitmap = Bitmap.createBitmap(BITMAP_WIDTH, 31, Config.ARGB_8888); |
| mCanvas.setBitmap(mMutableBitmap); |
| assertEquals(BITMAP_WIDTH, mCanvas.getWidth()); |
| assertEquals(31, mCanvas.getHeight()); |
| } |
| |
| @Test |
| public void testSetBitmapFromEmpty() { |
| Canvas canvas = new Canvas(); |
| assertEquals(0, canvas.getWidth()); |
| assertEquals(0, canvas.getHeight()); |
| |
| // now ensure that we can "grow" the canvas |
| |
| Bitmap normal = Bitmap.createBitmap(10, 10, Config.ARGB_8888); |
| canvas.setBitmap(normal); |
| assertEquals(10, canvas.getWidth()); |
| assertEquals(10, canvas.getHeight()); |
| |
| // now draw, and check that the clip was "open" |
| canvas.drawColor(0xFFFF0000); |
| assertEquals(0xFFFF0000, normal.getPixel(5, 5)); |
| } |
| |
| @Test |
| public void testSetBitmapCleanClip() { |
| mCanvas.setBitmap(Bitmap.createBitmap(10, 10, Config.ARGB_8888)); |
| Rect r = new Rect(2, 2, 8, 8); |
| mCanvas.save(); |
| mCanvas.clipRect(r); |
| assertEquals(r, mCanvas.getClipBounds()); |
| |
| // "reset" the canvas, and then check that the clip is wide open |
| // and not the previous value |
| |
| mCanvas.setBitmap(Bitmap.createBitmap(20, 20, Config.ARGB_8888)); |
| r = new Rect(0, 0, 20, 20); |
| assertEquals(r, mCanvas.getClipBounds()); |
| } |
| |
| @Test |
| public void testSetBitmapSaveCount() { |
| Canvas c = new Canvas(Bitmap.createBitmap(10, 10, Config.ARGB_8888)); |
| int initialSaveCount = c.getSaveCount(); |
| |
| c.save(); |
| assertEquals(c.getSaveCount(), initialSaveCount + 1); |
| |
| // setBitmap should restore the saveCount to its original/base value |
| c.setBitmap(Bitmap.createBitmap(10, 10, Config.ARGB_8888)); |
| assertEquals(c.getSaveCount(), initialSaveCount); |
| } |
| |
| @Test |
| public void testIsOpaque() { |
| assertFalse(mCanvas.isOpaque()); |
| } |
| |
| @Test(expected=IllegalStateException.class) |
| public void testRestoreWithoutSave() { |
| // Should throw out IllegalStateException because cannot restore Canvas before save |
| mCanvas.restore(); |
| } |
| |
| @Test |
| public void testRestore() { |
| mCanvas.save(); |
| mCanvas.restore(); |
| } |
| |
| @Test |
| public void testSave() { |
| final Matrix m1 = new Matrix(); |
| m1.setValues(values1); |
| mCanvas.setMatrix(m1); |
| mCanvas.save(); |
| |
| final Matrix m2 = new Matrix(); |
| m2.setValues(values2); |
| mCanvas.setMatrix(m2); |
| |
| final float[] values3 = new float[FLOAT_ARRAY_LEN]; |
| final Matrix m3 = mCanvas.getMatrix(); |
| m3.getValues(values3); |
| |
| assertArrayEquals(values2, values3, 0.0f); |
| |
| mCanvas.restore(); |
| final float[] values4 = new float[FLOAT_ARRAY_LEN]; |
| final Matrix m4 = mCanvas.getMatrix(); |
| m4.getValues(values4); |
| |
| assertArrayEquals(values1, values4, 0.0f); |
| } |
| |
| @Test |
| public void testSaveLayer1() { |
| final Paint p = new Paint(); |
| final RectF rF = new RectF(0, 10, 31, 0); |
| |
| // test save everything |
| Matrix m1 = new Matrix(); |
| m1.setValues(values1); |
| mCanvas.setMatrix(m1); |
| mCanvas.saveLayer(rF, p); |
| |
| Matrix m2 = new Matrix(); |
| m2.setValues(values2); |
| mCanvas.setMatrix(m2); |
| |
| float[] values3 = new float[FLOAT_ARRAY_LEN]; |
| Matrix m3 = mCanvas.getMatrix(); |
| m3.getValues(values3); |
| |
| assertArrayEquals(values2, values3, 0.0f); |
| |
| mCanvas.restore(); |
| float[] values4 = new float[FLOAT_ARRAY_LEN]; |
| Matrix m4 = mCanvas.getMatrix(); |
| m4.getValues(values4); |
| |
| assertArrayEquals(values1, values4, 0.0f); |
| } |
| |
| @Test |
| public void testSaveLayer2() { |
| final Paint p = new Paint(); |
| |
| // test save everything |
| Matrix m1 = new Matrix(); |
| m1.setValues(values1); |
| mCanvas.setMatrix(m1); |
| mCanvas.saveLayer(10, 0, 0, 31, p); |
| |
| Matrix m2 = new Matrix(); |
| m2.setValues(values2); |
| mCanvas.setMatrix(m2); |
| |
| float[] values3 = new float[FLOAT_ARRAY_LEN]; |
| Matrix m3 = mCanvas.getMatrix(); |
| m3.getValues(values3); |
| |
| assertArrayEquals(values2, values3, 0.0f); |
| |
| mCanvas.restore(); |
| float[] values4 = new float[FLOAT_ARRAY_LEN]; |
| Matrix m4 = mCanvas.getMatrix(); |
| m4.getValues(values4); |
| |
| assertArrayEquals(values1, values4, 0.0f); |
| } |
| |
| @Test |
| public void testSaveLayerAlpha1() { |
| final RectF rF = new RectF(0, 10, 31, 0); |
| |
| // test save everything |
| Matrix m1 = new Matrix(); |
| m1.setValues(values1); |
| mCanvas.setMatrix(m1); |
| mCanvas.saveLayerAlpha(rF, 0xff); |
| |
| Matrix m2 = new Matrix(); |
| m2.setValues(values2); |
| mCanvas.setMatrix(m2); |
| |
| float[] values3 = new float[FLOAT_ARRAY_LEN]; |
| Matrix m3 = mCanvas.getMatrix(); |
| m3.getValues(values3); |
| |
| assertArrayEquals(values2, values3, 0.0f); |
| |
| mCanvas.restore(); |
| float[] values4 = new float[FLOAT_ARRAY_LEN]; |
| Matrix m4 = mCanvas.getMatrix(); |
| m4.getValues(values4); |
| |
| assertArrayEquals(values1, values4, 0.0f); |
| } |
| |
| @Test |
| public void testSaveLayerAlpha2() { |
| // test save everything |
| Matrix m1 = new Matrix(); |
| m1.setValues(values1); |
| mCanvas.setMatrix(m1); |
| mCanvas.saveLayerAlpha(0, 10, 31, 0, 0xff); |
| |
| Matrix m2 = new Matrix(); |
| m2.setValues(values2); |
| mCanvas.setMatrix(m2); |
| |
| float[] values3 = new float[FLOAT_ARRAY_LEN]; |
| Matrix m3 = mCanvas.getMatrix(); |
| m3.getValues(values3); |
| |
| assertArrayEquals(values2, values3, 0.0f); |
| |
| mCanvas.restore(); |
| float[] values4 = new float[FLOAT_ARRAY_LEN]; |
| Matrix m4 = mCanvas.getMatrix(); |
| m4.getValues(values4); |
| |
| assertArrayEquals(values1, values4, 0.0f); |
| } |
| |
| @Test |
| public void testGetSaveCount() { |
| // why is 1 not 0 |
| assertEquals(1, mCanvas.getSaveCount()); |
| mCanvas.save(); |
| assertEquals(2, mCanvas.getSaveCount()); |
| mCanvas.save(); |
| assertEquals(3, mCanvas.getSaveCount()); |
| mCanvas.saveLayer(new RectF(), new Paint()); |
| assertEquals(4, mCanvas.getSaveCount()); |
| mCanvas.saveLayerAlpha(new RectF(), 0); |
| assertEquals(5, mCanvas.getSaveCount()); |
| } |
| |
| @Test(expected=IllegalArgumentException.class) |
| public void testRestoreToCountIllegalSaveCount() { |
| // Should throw out IllegalArgumentException because saveCount is less than 1 |
| mCanvas.restoreToCount(0); |
| } |
| |
| @Test |
| public void testRestoreToCountExceptionBehavior() { |
| int restoreTo = mCanvas.save(); |
| mCanvas.save(); |
| int beforeCount = mCanvas.getSaveCount(); |
| |
| boolean exceptionObserved = false; |
| try { |
| mCanvas.restoreToCount(restoreTo - 1); |
| } catch (IllegalArgumentException e) { |
| exceptionObserved = true; |
| } |
| |
| // restore to count threw, AND did no restoring |
| assertTrue(exceptionObserved); |
| assertEquals(beforeCount, mCanvas.getSaveCount()); |
| } |
| |
| @Test |
| public void testRestoreToCount() { |
| final Matrix m1 = new Matrix(); |
| m1.setValues(values1); |
| mCanvas.setMatrix(m1); |
| final int count = mCanvas.save(); |
| assertTrue(count > 0); |
| |
| final Matrix m2 = new Matrix(); |
| m2.setValues(values2); |
| mCanvas.setMatrix(m2); |
| |
| final float[] values3 = new float[FLOAT_ARRAY_LEN]; |
| final Matrix m3 = mCanvas.getMatrix(); |
| m3.getValues(values3); |
| |
| assertArrayEquals(values2, values3, 0.0f); |
| |
| mCanvas.restoreToCount(count); |
| final float[] values4 = new float[FLOAT_ARRAY_LEN]; |
| final Matrix m4 = mCanvas.getMatrix(); |
| m4.getValues(values4); |
| |
| assertArrayEquals(values1, values4, 0.0f); |
| } |
| |
| @Test |
| public void testGetMatrix1() { |
| final float[] f1 = { |
| 1, 2, 3, 4, 5, 6, 7, 8, 9 |
| }; |
| final Matrix m1 = new Matrix(); |
| m1.setValues(f1); |
| mCanvas.setMatrix(m1); |
| |
| final Matrix m2 = new Matrix(m1); |
| mCanvas.getMatrix(m2); |
| |
| assertTrue(m1.equals(m2)); |
| |
| final float[] f2 = new float[FLOAT_ARRAY_LEN]; |
| m2.getValues(f2); |
| |
| assertArrayEquals(f1, f2, 0.0f); |
| } |
| |
| @Test |
| public void testGetMatrix2() { |
| final float[] f1 = { |
| 1, 2, 3, 4, 5, 6, 7, 8, 9 |
| }; |
| final Matrix m1 = new Matrix(); |
| m1.setValues(f1); |
| |
| mCanvas.setMatrix(m1); |
| final Matrix m2 = mCanvas.getMatrix(); |
| |
| assertTrue(m1.equals(m2)); |
| |
| final float[] f2 = new float[FLOAT_ARRAY_LEN]; |
| m2.getValues(f2); |
| |
| assertArrayEquals(f1, f2, 0.0f); |
| } |
| |
| @Test |
| public void testTranslate() { |
| preCompare(); |
| |
| mCanvas.translate(0.10f, 0.28f); |
| |
| final float[] values = new float[FLOAT_ARRAY_LEN]; |
| mCanvas.getMatrix().getValues(values); |
| assertArrayEquals(new float[] { |
| 1.0f, 0.0f, 0.1f, 0.0f, 1.0f, 0.28f, 0.0f, 0.0f, 1.0f |
| }, values, 0.0f); |
| } |
| |
| @Test |
| public void testScale1() { |
| preCompare(); |
| |
| mCanvas.scale(0.5f, 0.5f); |
| |
| final float[] values = new float[FLOAT_ARRAY_LEN]; |
| mCanvas.getMatrix().getValues(values); |
| assertArrayEquals(new float[] { |
| 0.5f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f |
| }, values, 0.0f); |
| } |
| |
| @Test |
| public void testScale2() { |
| preCompare(); |
| |
| mCanvas.scale(3.0f, 3.0f, 1.0f, 1.0f); |
| |
| final float[] values = new float[FLOAT_ARRAY_LEN]; |
| mCanvas.getMatrix().getValues(values); |
| assertArrayEquals(new float[] { |
| 3.0f, 0.0f, -2.0f, 0.0f, 3.0f, -2.0f, 0.0f, 0.0f, 1.0f |
| }, values, 0.0f); |
| } |
| |
| @Test |
| public void testRotate1() { |
| preCompare(); |
| |
| mCanvas.rotate(90); |
| |
| final float[] values = new float[FLOAT_ARRAY_LEN]; |
| mCanvas.getMatrix().getValues(values); |
| assertArrayEquals(new float[] { |
| 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f |
| }, values, 0.0f); |
| } |
| |
| @Test |
| public void testRotate2() { |
| preCompare(); |
| |
| mCanvas.rotate(30, 1.0f, 0.0f); |
| |
| final float[] values = new float[FLOAT_ARRAY_LEN]; |
| mCanvas.getMatrix().getValues(values); |
| assertArrayEquals(new float[] { |
| 0.8660254f, -0.5f, 0.13397461f, 0.5f, 0.8660254f, -0.5f, 0.0f, 0.0f, 1.0f |
| }, values, 0.0f); |
| } |
| |
| @Test |
| public void testSkew() { |
| preCompare(); |
| |
| mCanvas.skew(1.0f, 3.0f); |
| |
| final float[] values = new float[FLOAT_ARRAY_LEN]; |
| mCanvas.getMatrix().getValues(values); |
| assertArrayEquals(new float[] { |
| 1.0f, 1.0f, 0.0f, 3.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f |
| }, values, 0.0f); |
| } |
| |
| @Test |
| public void testConcat() { |
| preCompare(); |
| |
| final Matrix m = new Matrix(); |
| final float[] values = {0, 1, 2, 3, 4, 5, 6, 7, 8}; |
| |
| m.setValues(values); |
| mCanvas.concat(m); |
| |
| mCanvas.getMatrix().getValues(values); |
| assertArrayEquals(new float[] { |
| 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f |
| }, values, 0.0f); |
| } |
| |
| @Test |
| public void testClipRectF() { |
| mCanvas.save(); |
| // intersect with clip larger than canvas |
| assertTrue(mCanvas.clipRect(new RectF(0, 0, 10, 31), Op.INTERSECT)); |
| // intersect with clip outside of canvas bounds |
| assertFalse(mCanvas.clipRect(new RectF(10, 31, 11, 32), Op.INTERSECT)); |
| // replace with the original clip |
| mCanvas.restore(); |
| // intersect with clip that covers top portion of canvas |
| assertTrue(mCanvas.clipRect(new RectF(0, 0, 20, 10), Op.INTERSECT)); |
| // intersect with clip that covers bottom portion of canvas |
| assertFalse(mCanvas.clipRect(new RectF(0, 10, 20, 32), Op.INTERSECT)); |
| // ensure that difference doesn't widen already closed clip |
| assertFalse(mCanvas.clipRect(new RectF(0, 0, 10, 31), Op.DIFFERENCE)); |
| } |
| |
| @Test |
| public void testClipRect() { |
| mCanvas.save(); |
| // intersect with clip larger than canvas |
| assertTrue(mCanvas.clipRect(new Rect(0, 0, 10, 31), Op.INTERSECT)); |
| // intersect with clip outside of canvas bounds |
| assertFalse(mCanvas.clipRect(new Rect(10, 31, 11, 32), Op.INTERSECT)); |
| // replace with the original clip |
| mCanvas.restore(); |
| // intersect with clip that covers top portion of canvas |
| assertTrue(mCanvas.clipRect(new Rect(0, 0, 20, 10), Op.INTERSECT)); |
| // intersect with clip that covers bottom portion of canvas |
| assertFalse(mCanvas.clipRect(new Rect(0, 10, 20, 32), Op.INTERSECT)); |
| // ensure that difference doesn't widen already closed clip |
| assertFalse(mCanvas.clipRect(new Rect(0, 0, 10, 31), Op.DIFFERENCE)); |
| } |
| |
| @Test |
| public void testClipRect4I() { |
| mCanvas.save(); |
| // intersect with clip larger than canvas |
| assertTrue(mCanvas.clipRect(0, 0, 10, 31, Op.INTERSECT)); |
| // intersect with clip outside of canvas bounds |
| assertFalse(mCanvas.clipRect(10, 31, 11, 32, Op.INTERSECT)); |
| // replace with the original clip |
| mCanvas.restore(); |
| // intersect with clip that covers top portion of canvas |
| assertTrue(mCanvas.clipRect(0, 0, 20, 10, Op.INTERSECT)); |
| // intersect with clip that covers bottom portion of canvas |
| assertFalse(mCanvas.clipRect(0, 10, 20, 32, Op.INTERSECT)); |
| // ensure that difference doesn't widen already closed clip |
| assertFalse(mCanvas.clipRect(0, 0, 10, 31, Op.DIFFERENCE)); |
| } |
| |
| @Test |
| public void testClipRect4F() { |
| mCanvas.save(); |
| // intersect with clip larger than canvas |
| assertTrue(mCanvas.clipRect(0f, 0f, 10f, 31f, Op.INTERSECT)); |
| // intersect with clip outside of canvas bounds |
| assertFalse(mCanvas.clipRect(10f, 31f, 11f, 32f, Op.INTERSECT)); |
| // replace with the original clip |
| mCanvas.restore(); |
| // intersect with clip that covers top portion of canvas |
| assertTrue(mCanvas.clipRect(0f, 0f, 20f, 10f, Op.INTERSECT)); |
| // intersect with clip that covers bottom portion of canvas |
| assertFalse(mCanvas.clipRect(0f, 10f, 20f, 32f, Op.INTERSECT)); |
| // ensure that difference doesn't widen already closed clip |
| assertFalse(mCanvas.clipRect(0f, 0f, 10f, 31f, Op.DIFFERENCE)); |
| } |
| |
| @Test |
| public void testClipOutRectF() { |
| // remove center, clip not empty |
| assertTrue(mCanvas.clipOutRect(new RectF(1, 1, 9, 27))); |
| // replace clip, verify difference doesn't widen |
| assertFalse(mCanvas.clipRect(new RectF(0, 0, 0, 0))); |
| assertFalse(mCanvas.clipOutRect(new RectF(0, 0, 100, 100))); |
| } |
| |
| @Test |
| public void testClipOutRect() { |
| // remove center, clip not empty |
| assertTrue(mCanvas.clipOutRect(new Rect(1, 1, 9, 27))); |
| // replace clip, verify difference doesn't widen |
| assertFalse(mCanvas.clipRect(new Rect(0, 0, 0, 0))); |
| assertFalse(mCanvas.clipOutRect(new Rect(0, 0, 100, 100))); |
| } |
| |
| @Test |
| public void testClipOutRect4I() { |
| // remove center, clip not empty |
| assertTrue(mCanvas.clipOutRect(1, 1, 9, 27)); |
| // replace clip, verify difference doesn't widen |
| assertFalse(mCanvas.clipRect(0, 0, 0, 0)); |
| assertFalse(mCanvas.clipOutRect(0, 0, 100, 100)); |
| } |
| |
| @Test |
| public void testClipOutRect4F() { |
| // remove center, clip not empty |
| assertTrue(mCanvas.clipOutRect(1f, 1f, 9f, 27f)); |
| // replace clip, verify difference doesn't widen |
| assertFalse(mCanvas.clipRect(0f, 0f, 0f, 0f)); |
| assertFalse(mCanvas.clipOutRect(0f, 0f, 100f, 100f)); |
| } |
| |
| @Test |
| public void testIntersectClipRectF() { |
| // intersect with clip larger than canvas |
| assertTrue(mCanvas.clipRect(new RectF(0, 0, 10, 31))); |
| // intersect with clip outside of canvas bounds |
| assertFalse(mCanvas.clipRect(new RectF(10, 31, 11, 32))); |
| } |
| |
| @Test |
| public void testIntersectClipRect() { |
| // intersect with clip larger than canvas |
| assertTrue(mCanvas.clipRect(new Rect(0, 0, 10, 31))); |
| // intersect with clip outside of canvas bounds |
| assertFalse(mCanvas.clipRect(new Rect(10, 31, 11, 32))); |
| } |
| |
| @Test |
| public void testIntersectClipRect4F() { |
| // intersect with clip larger than canvas |
| assertTrue(mCanvas.clipRect(0, 0, 10, 31)); |
| // intersect with clip outside of canvas bounds |
| assertFalse(mCanvas.clipRect(10, 31, 11, 32)); |
| } |
| |
| @Test |
| public void testClipPath1() { |
| final Path p = new Path(); |
| p.addRect(new RectF(0, 0, 10, 31), Direction.CCW); |
| assertTrue(mCanvas.clipPath(p)); |
| } |
| |
| @Test |
| public void testClipPath2() { |
| final Path p = new Path(); |
| p.addRect(new RectF(0, 0, 10, 31), Direction.CW); |
| |
| final Path pIn = new Path(); |
| pIn.addOval(new RectF(0, 0, 20, 10), Direction.CW); |
| |
| final Path pOut = new Path(); |
| pOut.addRoundRect(new RectF(10, 31, 11, 32), 0.5f, 0.5f, Direction.CW); |
| |
| mCanvas.save(); |
| // intersect with clip larger than canvas |
| assertTrue(mCanvas.clipPath(p, Op.INTERSECT)); |
| // intersect with clip outside of canvas bounds |
| assertFalse(mCanvas.clipPath(pOut, Op.INTERSECT)); |
| // replace with the original clip |
| mCanvas.restore(); |
| // intersect with clip that covers top portion of canvas |
| assertTrue(mCanvas.clipPath(pIn, Op.INTERSECT)); |
| // intersect with clip outside of canvas bounds |
| assertFalse(mCanvas.clipPath(pOut, Op.INTERSECT)); |
| // ensure that difference doesn't widen already closed clip |
| assertFalse(mCanvas.clipPath(p, Op.DIFFERENCE)); |
| } |
| |
| @Test |
| public void testClipOutPath() { |
| final Path p = new Path(); |
| p.addRect(new RectF(5, 5, 10, 10), Direction.CW); |
| assertTrue(mCanvas.clipOutPath(p)); |
| } |
| |
| @Test |
| public void testClipInversePath() { |
| final Path p = new Path(); |
| p.addRoundRect(new RectF(0, 0, 10, 10), 0.5f, 0.5f, Direction.CW); |
| p.setFillType(Path.FillType.INVERSE_WINDING); |
| assertTrue(mCanvas.clipPath(p, Op.INTERSECT)); |
| |
| mCanvas.drawColor(PAINT_COLOR); |
| |
| assertEquals(Color.TRANSPARENT, mMutableBitmap.getPixel(0, 0)); |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(0, 20)); |
| } |
| |
| @Test |
| public void testGetDrawFilter() { |
| assertNull(mCanvas.getDrawFilter()); |
| final DrawFilter dF = new DrawFilter(); |
| mCanvas.setDrawFilter(dF); |
| |
| assertTrue(dF.equals(mCanvas.getDrawFilter())); |
| } |
| |
| @Test |
| public void testQuickReject1() { |
| assertFalse(mCanvas.quickReject(new RectF(0, 0, 10, 31), EdgeType.AA)); |
| assertFalse(mCanvas.quickReject(new RectF(0, 0, 10, 31), EdgeType.BW)); |
| } |
| |
| @Test |
| public void testQuickReject2() { |
| final Path p = new Path(); |
| p.addRect(new RectF(0, 0, 10, 31), Direction.CCW); |
| |
| assertFalse(mCanvas.quickReject(p, EdgeType.AA)); |
| assertFalse(mCanvas.quickReject(p, EdgeType.BW)); |
| } |
| |
| @Test |
| public void testQuickReject3() { |
| assertFalse(mCanvas.quickReject(0, 0, 10, 31, EdgeType.AA)); |
| assertFalse(mCanvas.quickReject(0, 0, 10, 31, EdgeType.BW)); |
| } |
| |
| @Test |
| public void testGetClipBounds1() { |
| final Rect r = new Rect(); |
| |
| assertTrue(mCanvas.getClipBounds(r)); |
| assertEquals(BITMAP_WIDTH, r.width()); |
| assertEquals(BITMAP_HEIGHT, r.height()); |
| } |
| |
| @Test |
| public void testGetClipBounds2() { |
| final Rect r = mCanvas.getClipBounds(); |
| |
| assertEquals(BITMAP_WIDTH, r.width()); |
| assertEquals(BITMAP_HEIGHT, r.height()); |
| } |
| |
| private void verifyDrewColor(int color) { |
| assertEquals(color, mMutableBitmap.getPixel(0, 0)); |
| assertEquals(color, mMutableBitmap.getPixel(BITMAP_WIDTH / 2, BITMAP_HEIGHT / 2)); |
| assertEquals(color, mMutableBitmap.getPixel(BITMAP_WIDTH - 1, BITMAP_HEIGHT - 1)); |
| } |
| |
| @Test |
| public void testDrawRGB() { |
| final int alpha = 0xff; |
| final int red = 0xff; |
| final int green = 0xff; |
| final int blue = 0xff; |
| |
| mCanvas.drawRGB(red, green, blue); |
| |
| final int color = alpha << 24 | red << 16 | green << 8 | blue; |
| verifyDrewColor(color); |
| } |
| |
| @Test |
| public void testDrawARGB() { |
| final int alpha = 0xff; |
| final int red = 0x22; |
| final int green = 0x33; |
| final int blue = 0x44; |
| |
| mCanvas.drawARGB(alpha, red, green, blue); |
| final int color = alpha << 24 | red << 16 | green << 8 | blue; |
| verifyDrewColor(color); |
| } |
| |
| @Test |
| public void testDrawColor1() { |
| final int color = Color.RED; |
| |
| mCanvas.drawColor(color); |
| verifyDrewColor(color); |
| } |
| |
| @Test |
| public void testDrawColor2() { |
| mCanvas.drawColor(Color.RED, Mode.CLEAR); |
| mCanvas.drawColor(Color.RED, Mode.DARKEN); |
| mCanvas.drawColor(Color.RED, Mode.DST); |
| mCanvas.drawColor(Color.RED, Mode.DST_ATOP); |
| mCanvas.drawColor(Color.RED, Mode.DST_IN); |
| mCanvas.drawColor(Color.RED, Mode.DST_OUT); |
| mCanvas.drawColor(Color.RED, Mode.DST_OVER); |
| mCanvas.drawColor(Color.RED, Mode.LIGHTEN); |
| mCanvas.drawColor(Color.RED, Mode.MULTIPLY); |
| mCanvas.drawColor(Color.RED, Mode.SCREEN); |
| mCanvas.drawColor(Color.RED, Mode.SRC); |
| mCanvas.drawColor(Color.RED, Mode.SRC_ATOP); |
| mCanvas.drawColor(Color.RED, Mode.SRC_IN); |
| mCanvas.drawColor(Color.RED, Mode.SRC_OUT); |
| mCanvas.drawColor(Color.RED, Mode.SRC_OVER); |
| mCanvas.drawColor(Color.RED, Mode.XOR); |
| } |
| |
| @Test |
| public void testDrawPaint() { |
| mCanvas.drawPaint(mPaint); |
| |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(0, 0)); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawPointsInvalidOffset() { |
| // Should throw out ArrayIndexOutOfBoundsException because of invalid offset |
| mCanvas.drawPoints(new float[]{ |
| 10.0f, 29.0f |
| }, -1, 2, mPaint); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawPointsInvalidCount() { |
| // Should throw out ArrayIndexOutOfBoundsException because of invalid count |
| mCanvas.drawPoints(new float[]{ |
| 10.0f, 29.0f |
| }, 0, 31, mPaint); |
| } |
| |
| @Test |
| public void testDrawPoints1() { |
| // normal case |
| mCanvas.drawPoints(new float[] { |
| 0, 0 |
| }, 0, 2, mPaint); |
| |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(0, 0)); |
| } |
| |
| @Test |
| public void testDrawPoints2() { |
| mCanvas.drawPoints(new float[]{0, 0}, mPaint); |
| |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(0, 0)); |
| } |
| |
| @Test |
| public void testDrawPoint() { |
| mCanvas.drawPoint(0, 0, mPaint); |
| |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(0, 0)); |
| } |
| |
| @Test |
| public void testDrawLine() { |
| mCanvas.drawLine(0, 0, 10, 12, mPaint); |
| |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(0, 0)); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawLinesInvalidOffset() { |
| // Should throw out ArrayIndexOutOfBoundsException because of invalid offset |
| mCanvas.drawLines(new float[]{ |
| 0, 0, 10, 31 |
| }, 2, 4, new Paint()); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawLinesInvalidCount() { |
| // Should throw out ArrayIndexOutOfBoundsException because of invalid count |
| mCanvas.drawLines(new float[]{ |
| 0, 0, 10, 31 |
| }, 0, 8, new Paint()); |
| } |
| |
| @Test |
| public void testDrawLines1() { |
| // normal case |
| mCanvas.drawLines(new float[] { |
| 0, 0, 10, 12 |
| }, 0, 4, mPaint); |
| |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(0, 0)); |
| } |
| |
| @Test |
| public void testDrawLines2() { |
| mCanvas.drawLines(new float[] { |
| 0, 0, 10, 12 |
| }, mPaint); |
| |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(0, 0)); |
| } |
| |
| private void verifyDrewPaint() { |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(0, 0)); |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(5, 6)); |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(9, 11)); |
| } |
| |
| @Test |
| public void testDrawRect1() { |
| mCanvas.drawRect(new RectF(0, 0, 10, 12), mPaint); |
| |
| verifyDrewPaint(); |
| } |
| |
| @Test |
| public void testDrawRect2() { |
| mCanvas.drawRect(new Rect(0, 0, 10, 12), mPaint); |
| |
| verifyDrewPaint(); |
| } |
| |
| @Test |
| public void testDrawRect3() { |
| mCanvas.drawRect(0, 0, 10, 12, mPaint); |
| |
| verifyDrewPaint(); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testDrawOvalNull() { |
| // Should throw out NullPointerException because oval is null |
| mCanvas.drawOval(null, mPaint); |
| } |
| |
| @Test |
| public void testDrawOval() { |
| // normal case |
| mCanvas.drawOval(new RectF(0, 0, 10, 12), mPaint); |
| } |
| |
| @Test |
| public void testDrawCircle() { |
| // special case: circle's radius <= 0 |
| mCanvas.drawCircle(10.0f, 10.0f, -1.0f, mPaint); |
| |
| // normal case |
| mCanvas.drawCircle(10, 12, 3, mPaint); |
| |
| assertEquals(PAINT_COLOR, mMutableBitmap.getPixel(9, 11)); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testDrawArcNullOval() { |
| // Should throw NullPointerException because oval is null |
| mCanvas.drawArc(null, 10.0f, 29.0f, true, mPaint); |
| } |
| |
| @Test |
| public void testDrawArc() { |
| // normal case |
| mCanvas.drawArc(new RectF(0, 0, 10, 12), 10, 11, false, mPaint); |
| mCanvas.drawArc(new RectF(0, 0, 10, 12), 10, 11, true, mPaint); |
| |
| // special case: sweepAngle >= abs(360) |
| mCanvas.drawArc(new RectF(0, 0, 10, 12), 10, 400, true, mPaint); |
| mCanvas.drawArc(new RectF(0, 0, 10, 12), 10, -400, true, mPaint); |
| mCanvas.drawArc(new RectF(0, 0, 10, 12), 10, Float.POSITIVE_INFINITY, true, mPaint); |
| mCanvas.drawArc(new RectF(0, 0, 10, 12), 10, Float.NEGATIVE_INFINITY, true, mPaint); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testDrawRoundRectNull() { |
| // Should throw out NullPointerException because RoundRect is null |
| mCanvas.drawRoundRect(null, 10.0f, 29.0f, mPaint); |
| } |
| |
| @Test |
| public void testDrawRoundRect() { |
| mCanvas.drawRoundRect(new RectF(0, 0, 10, 12), 8, 8, mPaint); |
| } |
| |
| @Test |
| public void testDrawPath() { |
| mCanvas.drawPath(new Path(), mPaint); |
| } |
| |
| @Test(expected=RuntimeException.class) |
| public void testDrawBitmapAtPointRecycled() { |
| Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| b.recycle(); |
| |
| // Should throw out RuntimeException because bitmap has been recycled |
| mCanvas.drawBitmap(b, 10.0f, 29.0f, mPaint); |
| } |
| |
| @Test |
| public void testDrawBitmapAtPoint() { |
| Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 12, Config.ARGB_8888); |
| mCanvas.drawBitmap(b, 10, 12, null); |
| mCanvas.drawBitmap(b, 5, 12, mPaint); |
| } |
| |
| @Test(expected=RuntimeException.class) |
| public void testDrawBitmapSrcDstFloatRecycled() { |
| Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| b.recycle(); |
| |
| // Should throw out RuntimeException because bitmap has been recycled |
| mCanvas.drawBitmap(b, null, new RectF(), mPaint); |
| } |
| |
| @Test |
| public void testDrawBitmapSrcDstFloat() { |
| Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| mCanvas.drawBitmap(b, new Rect(), new RectF(), null); |
| mCanvas.drawBitmap(b, new Rect(), new RectF(), mPaint); |
| } |
| |
| @Test(expected=RuntimeException.class) |
| public void testDrawBitmapSrcDstIntRecycled() { |
| Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| b.recycle(); |
| |
| // Should throw out RuntimeException because bitmap has been recycled |
| mCanvas.drawBitmap(b, null, new Rect(), mPaint); |
| } |
| |
| @Test |
| public void testDrawBitmapSrcDstInt() { |
| Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| mCanvas.drawBitmap(b, new Rect(), new Rect(), null); |
| mCanvas.drawBitmap(b, new Rect(), new Rect(), mPaint); |
| } |
| |
| @Test(expected=IllegalArgumentException.class) |
| public void testDrawBitmapIntsNegativeWidth() { |
| // Should throw out IllegalArgumentException because width is less than 0 |
| mCanvas.drawBitmap(new int[2008], 10, 10, 10, 10, -1, 10, true, null); |
| } |
| |
| @Test(expected=IllegalArgumentException.class) |
| public void testDrawBitmapIntsNegativeHeight() { |
| // Should throw out IllegalArgumentException because height is less than 0 |
| mCanvas.drawBitmap(new int[2008], 10, 10, 10, 10, 10, -1, true, null); |
| } |
| |
| @Test(expected=IllegalArgumentException.class) |
| public void testDrawBitmapIntsBadStride() { |
| // Should throw out IllegalArgumentException because stride less than width and |
| // bigger than -width |
| mCanvas.drawBitmap(new int[2008], 10, 5, 10, 10, 10, 10, true, null); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawBitmapIntsNegativeOffset() { |
| // Should throw out ArrayIndexOutOfBoundsException because offset less than 0 |
| mCanvas.drawBitmap(new int[2008], -1, 10, 10, 10, 10, 10, true, null); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawBitmapIntsBadOffset() { |
| // Should throw out ArrayIndexOutOfBoundsException because sum of offset and width |
| // is bigger than colors' length |
| mCanvas.drawBitmap(new int[29], 10, 29, 10, 10, 20, 10, true, null); |
| } |
| |
| @Test |
| public void testDrawBitmapInts() { |
| final int[] colors = new int[2008]; |
| |
| // special case: width equals to 0 |
| mCanvas.drawBitmap(colors, 10, 10, 10, 10, 0, 10, true, null); |
| |
| // special case: height equals to 0 |
| mCanvas.drawBitmap(colors, 10, 10, 10, 10, 10, 0, true, null); |
| |
| // normal case |
| mCanvas.drawBitmap(colors, 10, 10, 10, 10, 10, 29, true, null); |
| mCanvas.drawBitmap(colors, 10, 10, 10, 10, 10, 29, true, mPaint); |
| } |
| |
| @Test(expected=IllegalArgumentException.class) |
| public void testDrawBitmapFloatsNegativeWidth() { |
| // Should throw out IllegalArgumentException because width is less than 0 |
| mCanvas.drawBitmap(new int[2008], 10, 10, 10.0f, 10.0f, -1, 10, true, null); |
| } |
| |
| @Test(expected=IllegalArgumentException.class) |
| public void testDrawBitmapFloatsNegativeHeight() { |
| // Should throw out IllegalArgumentException because height is less than 0 |
| mCanvas.drawBitmap(new int[2008], 10, 10, 10.0f, 10.0f, 10, -1, true, null); |
| } |
| |
| @Test(expected=IllegalArgumentException.class) |
| public void testDrawBitmapFloatsBadStride() { |
| // Should throw out IllegalArgumentException because stride less than width and |
| // bigger than -width |
| mCanvas.drawBitmap(new int[2008], 10, 5, 10.0f, 10.0f, 10, 10, true, null); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawBitmapFloatsNegativeOffset() { |
| // Should throw out ArrayIndexOutOfBoundsException because offset less than 0 |
| mCanvas.drawBitmap(new int[2008], -1, 10, 10.0f, 10.0f, 10, 10, true, null); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawBitmapFloatsBadOffset() { |
| // Should throw out ArrayIndexOutOfBoundsException because sum of offset and width |
| // is bigger than colors' length |
| mCanvas.drawBitmap(new int[29], 10, 29, 10.0f, 10.0f, 20, 10, true, null); |
| } |
| |
| @Test |
| public void testDrawBitmapFloats() { |
| final int[] colors = new int[2008]; |
| |
| // special case: width equals to 0 |
| mCanvas.drawBitmap(colors, 10, 10, 10.0f, 10.0f, 0, 10, true, null); |
| |
| // special case: height equals to 0 |
| mCanvas.drawBitmap(colors, 10, 10, 10.0f, 10.0f, 10, 0, true, null); |
| |
| // normal case |
| mCanvas.drawBitmap(colors, 10, 10, 10.0f, 10.0f, 10, 29, true, null); |
| mCanvas.drawBitmap(colors, 10, 10, 10.0f, 10.0f, 10, 29, true, mPaint); |
| } |
| |
| @Test |
| public void testDrawBitmapMatrix() { |
| final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| mCanvas.drawBitmap(b, new Matrix(), null); |
| mCanvas.drawBitmap(b, new Matrix(), mPaint); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawBitmapMeshNegativeWidth() { |
| final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| |
| // Should throw out ArrayIndexOutOfBoundsException because meshWidth less than 0 |
| mCanvas.drawBitmapMesh(b, -1, 10, null, 0, null, 0, null); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawBitmapMeshNegativeHeight() { |
| final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| |
| // Should throw out ArrayIndexOutOfBoundsException because meshHeight is less than 0 |
| mCanvas.drawBitmapMesh(b, 10, -1, null, 0, null, 0, null); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawBitmapMeshNegativeVertOffset() { |
| final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| |
| // Should throw out ArrayIndexOutOfBoundsException because vertOffset is less than 0 |
| mCanvas.drawBitmapMesh(b, 10, 10, null, -1, null, 0, null); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawBitmapMeshNegativeColorOffset() { |
| final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| |
| // Should throw out ArrayIndexOutOfBoundsException because colorOffset is less than 0 |
| mCanvas.drawBitmapMesh(b, 10, 10, null, 10, null, -1, null); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawBitmapMeshTooFewVerts() { |
| final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| |
| // Should throw out ArrayIndexOutOfBoundsException because verts' length is too short |
| mCanvas.drawBitmapMesh(b, 10, 10, new float[] { |
| 10.0f, 29.0f |
| }, 10, null, 10, null); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawBitmapMeshTooFewColors() { |
| final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| |
| // Should throw out ArrayIndexOutOfBoundsException because colors' length is too short |
| // abnormal case: colors' length is too short |
| final float[] verts = new float[2008]; |
| mCanvas.drawBitmapMesh(b, 10, 10, verts, 10, new int[] { |
| 10, 29 |
| }, 10, null); |
| } |
| |
| @Test |
| public void testDrawBitmapMesh() { |
| final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Config.ARGB_8888); |
| |
| // special case: meshWidth equals to 0 |
| mCanvas.drawBitmapMesh(b, 0, 10, null, 10, null, 10, null); |
| |
| // special case: meshHeight equals to 0 |
| mCanvas.drawBitmapMesh(b, 10, 0, null, 10, null, 10, null); |
| |
| // normal case |
| final float[] verts = new float[2008]; |
| final int[] colors = new int[2008]; |
| mCanvas.drawBitmapMesh(b, 10, 10, verts, 10, colors, 10, null); |
| mCanvas.drawBitmapMesh(b, 10, 10, verts, 10, colors, 10, mPaint); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawVerticesTooFewVerts() { |
| final float[] verts = new float[10]; |
| final float[] texs = new float[10]; |
| final int[] colors = new int[10]; |
| final short[] indices = { |
| 0, 1, 2, 3, 4, 1 |
| }; |
| |
| // Should throw out ArrayIndexOutOfBoundsException because sum of vertOffset and |
| // vertexCount is bigger than verts' length |
| mCanvas.drawVertices(VertexMode.TRIANGLES, 10, verts, 8, texs, 0, colors, 0, indices, |
| 0, 4, mPaint); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawVerticesTooFewTexs() { |
| final float[] verts = new float[10]; |
| final float[] texs = new float[10]; |
| final int[] colors = new int[10]; |
| final short[] indices = { |
| 0, 1, 2, 3, 4, 1 |
| }; |
| |
| // Should throw out ArrayIndexOutOfBoundsException because sum of texOffset and |
| // vertexCount is bigger thatn texs' length |
| mCanvas.drawVertices(VertexMode.TRIANGLES, 10, verts, 0, texs, 30, colors, 0, indices, |
| 0, 4, mPaint); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawVerticesTooFewColors() { |
| final float[] verts = new float[10]; |
| final float[] texs = new float[10]; |
| final int[] colors = new int[10]; |
| final short[] indices = { |
| 0, 1, 2, 3, 4, 1 |
| }; |
| |
| // Should throw out ArrayIndexOutOfBoundsException because sum of colorOffset and |
| // vertexCount is bigger than colors' length |
| mCanvas.drawVertices(VertexMode.TRIANGLES, 10, verts, 0, texs, 0, colors, 30, indices, |
| 0, 4, mPaint); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawVerticesTooFewIndices() { |
| final float[] verts = new float[10]; |
| final float[] texs = new float[10]; |
| final int[] colors = new int[10]; |
| final short[] indices = { |
| 0, 1, 2, 3, 4, 1 |
| }; |
| |
| // Should throw out ArrayIndexOutOfBoundsException because sum of indexOffset and |
| // indexCount is bigger than indices' length |
| mCanvas.drawVertices(VertexMode.TRIANGLES, 10, verts, 0, texs, 0, colors, 0, indices, |
| 10, 30, mPaint); |
| } |
| |
| @Test |
| public void testDrawVertices() { |
| final float[] verts = new float[10]; |
| final float[] texs = new float[10]; |
| final int[] colors = new int[10]; |
| final short[] indices = { |
| 0, 1, 2, 3, 4, 1 |
| }; |
| |
| // special case: in texs, colors, indices, one of them, two of them and |
| // all are null |
| mCanvas.drawVertices(VertexMode.TRIANGLES, 0, verts, 0, null, 0, colors, 0, indices, 0, 0, |
| mPaint); |
| |
| mCanvas.drawVertices(VertexMode.TRIANGLE_STRIP, 0, verts, 0, null, 0, null, 0, indices, 0, |
| 0, mPaint); |
| |
| mCanvas.drawVertices(VertexMode.TRIANGLE_FAN, 0, verts, 0, null, 0, null, 0, null, 0, 0, |
| mPaint); |
| |
| // normal case: texs, colors, indices are not null |
| mCanvas.drawVertices(VertexMode.TRIANGLES, 10, verts, 0, texs, 0, colors, 0, indices, 0, 6, |
| mPaint); |
| |
| mCanvas.drawVertices(VertexMode.TRIANGLE_STRIP, 10, verts, 0, texs, 0, colors, 0, indices, |
| 0, 6, mPaint); |
| |
| mCanvas.drawVertices(VertexMode.TRIANGLE_FAN, 10, verts, 0, texs, 0, colors, 0, indices, 0, |
| 6, mPaint); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawArrayTextNegativeIndex() { |
| final char[] text = { 'a', 'n', 'd', 'r', 'o', 'i', 'd' }; |
| |
| // Should throw out IndexOutOfBoundsException because index is less than 0 |
| mCanvas.drawText(text, -1, 7, 10, 10, mPaint); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawArrayTextNegativeCount() { |
| final char[] text = { 'a', 'n', 'd', 'r', 'o', 'i', 'd' }; |
| |
| // Should throw out IndexOutOfBoundsException because count is less than 0 |
| mCanvas.drawText(text, 0, -1, 10, 10, mPaint); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawArrayTextTextLengthTooSmall() { |
| final char[] text = { 'a', 'n', 'd', 'r', 'o', 'i', 'd' }; |
| |
| // Should throw out IndexOutOfBoundsException because sum of index and count |
| // is bigger than text's length |
| mCanvas.drawText(text, 0, 10, 10, 10, mPaint); |
| } |
| |
| @Test |
| public void testDrawArrayText() { |
| final char[] text = { 'a', 'n', 'd', 'r', 'o', 'i', 'd' }; |
| |
| // normal case |
| mCanvas.drawText(text, 0, 7, 10, 10, mPaint); |
| } |
| |
| @Test |
| public void testDrawStringTextAtPosition() { |
| mCanvas.drawText("android", 10, 30, mPaint); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextTextAtPositionWithOffsetsNegativeStart() { |
| // Should throw out IndexOutOfBoundsException because start is less than 0 |
| mCanvas.drawText("android", -1, 7, 10, 30, mPaint); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextTextAtPositionWithOffsetsNegativeEnd() { |
| // Should throw out IndexOutOfBoundsException because end is less than 0 |
| mCanvas.drawText("android", 0, -1, 10, 30, mPaint); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextTextAtPositionWithOffsetsStartEndMismatch() { |
| // Should throw out IndexOutOfBoundsException because start is bigger than end |
| mCanvas.drawText("android", 3, 1, 10, 30, mPaint); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextTextAtPositionWithOffsetsTextTooLong() { |
| // Should throw out IndexOutOfBoundsException because end subtracts start should |
| // bigger than text's length |
| mCanvas.drawText("android", 0, 10, 10, 30, mPaint); |
| } |
| |
| @Test |
| public void testDrawTextTextAtPositionWithOffsets() { |
| final String t1 = "android"; |
| mCanvas.drawText(t1, 0, 7, 10, 30, mPaint); |
| |
| final SpannedString t2 = new SpannedString(t1); |
| mCanvas.drawText(t2, 0, 7, 10, 30, mPaint); |
| |
| final SpannableString t3 = new SpannableString(t2); |
| mCanvas.drawText(t3, 0, 7, 10, 30, mPaint); |
| |
| final SpannableStringBuilder t4 = new SpannableStringBuilder(t1); |
| mCanvas.drawText(t4, 0, 7, 10, 30, mPaint); |
| |
| final StringBuffer t5 = new StringBuffer(t1); |
| mCanvas.drawText(t5, 0, 7, 10, 30, mPaint); |
| } |
| |
| @Test |
| public void testDrawTextRun() { |
| final String text = "android"; |
| final Paint paint = new Paint(); |
| |
| mCanvas.drawTextRun(text, 0, 0, 0, 0, 0.0f, 0.0f, false, paint); |
| mCanvas.drawTextRun(text, 0, text.length(), 0, text.length(), 0.0f, 0.0f, false, paint); |
| mCanvas.drawTextRun(text, text.length(), text.length(), text.length(), text.length(), |
| 0.0f, 0.0f, false, paint); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testDrawTextRunNullCharArray() { |
| // Should throw out NullPointerException because text is null |
| mCanvas.drawTextRun((char[]) null, 0, 0, 0, 0, 0.0f, 0.0f, false, new Paint()); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testDrawTextRunNullCharSequence() { |
| // Should throw out NullPointerException because text is null |
| mCanvas.drawTextRun((CharSequence) null, 0, 0, 0, 0, 0.0f, 0.0f, false, new Paint()); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testDrawTextRunCharArrayNullPaint() { |
| // Should throw out NullPointerException because paint is null |
| mCanvas.drawTextRun("android".toCharArray(), 0, 0, 0, 0, 0.0f, 0.0f, false, null); |
| } |
| |
| @Test(expected=NullPointerException.class) |
| public void testDrawTextRunCharSequenceNullPaint() { |
| // Should throw out NullPointerException because paint is null |
| mCanvas.drawTextRun("android", 0, 0, 0, 0, 0.0f, 0.0f, false, null); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextRunNegativeIndex() { |
| final String text = "android"; |
| final Paint paint = new Paint(); |
| |
| // Should throw out IndexOutOfBoundsException because index is less than 0 |
| mCanvas.drawTextRun(text.toCharArray(), -1, text.length(), 0, text.length(), 0.0f, 0.0f, |
| false, new Paint()); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextRunNegativeCount() { |
| final String text = "android"; |
| |
| // Should throw out IndexOutOfBoundsException because count is less than 0 |
| mCanvas.drawTextRun(text.toCharArray(), 0, -1, 0, text.length(), 0.0f, 0.0f, false, |
| new Paint()); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextRunContestIndexTooLarge() { |
| final String text = "android"; |
| |
| // Should throw out IndexOutOfBoundsException because contextIndex is bigger than index |
| mCanvas.drawTextRun(text.toCharArray(), 0, text.length(), 1, text.length(), 0.0f, 0.0f, |
| false, new Paint()); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextRunContestIndexTooSmall() { |
| final String text = "android"; |
| |
| // Should throw out IndexOutOfBoundsException because contextIndex + contextCount |
| // is less than index + count |
| mCanvas.drawTextRun(text, 0, text.length(), 0, text.length() - 1, 0.0f, 0.0f, false, |
| new Paint()); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextRunIndexTooLarge() { |
| final String text = "android"; |
| final Paint paint = new Paint(); |
| |
| // Should throw out IndexOutOfBoundsException because index + count is bigger than |
| // text length |
| mCanvas.drawTextRun(text.toCharArray(), 0, text.length() + 1, 0, text.length() + 1, |
| 0.0f, 0.0f, false, new Paint()); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextRunNegativeContextStart() { |
| final String text = "android"; |
| final Paint paint = new Paint(); |
| |
| // Should throw out IndexOutOfBoundsException because contextStart is less than 0 |
| mCanvas.drawTextRun(text, 0, text.length(), -1, text.length(), 0.0f, 0.0f, false, |
| new Paint()); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextRunStartLessThanContextStart() { |
| final String text = "android"; |
| |
| // Should throw out IndexOutOfBoundsException because start is less than contextStart |
| mCanvas.drawTextRun(text, 0, text.length(), 1, text.length(), 0.0f, 0.0f, false, |
| new Paint()); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextRunEndLessThanStart() { |
| final String text = "android"; |
| |
| // Should throw out IndexOutOfBoundsException because end is less than start |
| mCanvas.drawTextRun(text, 1, 0, 0, text.length(), 0.0f, 0.0f, false, new Paint()); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextRunContextEndLessThanEnd() { |
| final String text = "android"; |
| |
| // Should throw out IndexOutOfBoundsException because contextEnd is less than end |
| mCanvas.drawTextRun(text, 0, text.length(), 0, text.length() - 1, 0.0f, 0.0f, false, |
| new Paint()); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawTextRunContextEndLargerThanTextLength() { |
| final String text = "android"; |
| |
| // Should throw out IndexOutOfBoundsException because contextEnd is bigger than |
| // text length |
| mCanvas.drawTextRun(text, 0, text.length(), 0, text.length() + 1, 0.0f, 0.0f, false, |
| new Paint()); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawPosTextWithIndexAndCountNegativeIndex() { |
| final char[] text = { |
| 'a', 'n', 'd', 'r', 'o', 'i', 'd' |
| }; |
| final float[] pos = new float[]{ |
| 0.0f, 0.0f, 1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f, 4.0f, 4.0f, 5.0f, 5.0f, 6.0f, 6.0f, |
| 7.0f, 7.0f |
| }; |
| |
| // Should throw out IndexOutOfBoundsException because index is less than 0 |
| mCanvas.drawPosText(text, -1, 7, pos, mPaint); |
| } |
| |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawPosTextWithIndexAndCountTextTooShort() { |
| final char[] text = { |
| 'a', 'n', 'd', 'r', 'o', 'i', 'd' |
| }; |
| final float[] pos = new float[]{ |
| 0.0f, 0.0f, 1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f, 4.0f, 4.0f, 5.0f, 5.0f, 6.0f, 6.0f, |
| 7.0f, 7.0f |
| }; |
| |
| // Should throw out IndexOutOfBoundsException because sum of index and count is |
| // bigger than text's length |
| mCanvas.drawPosText(text, 1, 10, pos, mPaint); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawPosTextWithIndexAndCountCountTooLarge() { |
| final char[] text = { |
| 'a', 'n', 'd', 'r', 'o', 'i', 'd' |
| }; |
| |
| // Should throw out IndexOutOfBoundsException because 2 times of count is |
| // bigger than pos' length |
| mCanvas.drawPosText(text, 1, 10, new float[] { |
| 10.0f, 30.f |
| }, mPaint); |
| } |
| |
| @Test |
| public void testDrawPosTextWithIndexAndCount() { |
| final char[] text = { |
| 'a', 'n', 'd', 'r', 'o', 'i', 'd' |
| }; |
| final float[] pos = new float[]{ |
| 0.0f, 0.0f, 1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f, 4.0f, 4.0f, 5.0f, 5.0f, 6.0f, 6.0f, |
| 7.0f, 7.0f |
| }; |
| |
| // normal case |
| mCanvas.drawPosText(text, 0, 7, pos, mPaint); |
| } |
| |
| @Test(expected=IndexOutOfBoundsException.class) |
| public void testDrawPosTextCountTooLarge() { |
| final String text = "android"; |
| |
| // Should throw out IndexOutOfBoundsException because 2 times of count is |
| // bigger than pos' length |
| mCanvas.drawPosText(text, new float[]{ |
| 10.0f, 30.f |
| }, mPaint); |
| } |
| |
| @Test |
| public void testDrawPosText() { |
| final String text = "android"; |
| final float[] pos = new float[]{ |
| 0.0f, 0.0f, 1.0f, 1.0f, 2.0f, 2.0f, 3.0f, 3.0f, 4.0f, 4.0f, 5.0f, 5.0f, 6.0f, 6.0f, |
| 7.0f, 7.0f |
| }; |
| // normal case |
| mCanvas.drawPosText(text, pos, mPaint); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawTextOnPathWithIndexAndCountNegativeIndex() { |
| final char[] text = { 'a', 'n', 'd', 'r', 'o', 'i', 'd' }; |
| |
| // Should throw out ArrayIndexOutOfBoundsException because index is smaller than 0 |
| mCanvas.drawTextOnPath(text, -1, 7, new Path(), 10.0f, 10.0f, mPaint); |
| } |
| |
| @Test(expected=ArrayIndexOutOfBoundsException.class) |
| public void testDrawTextOnPathWithIndexAndCountTextTooShort() { |
| final char[] text = { 'a', 'n', 'd', 'r', 'o', 'i', 'd' }; |
| |
| // Should throw out ArrayIndexOutOfBoundsException because sum of index and |
| // count is bigger than text's length |
| mCanvas.drawTextOnPath(text, 0, 10, new Path(), 10.0f, 10.0f, mPaint); |
| } |
| |
| @Test |
| public void testDrawTextOnPathWithIndexAndCount() { |
| final char[] text = { 'a', 'n', 'd', 'r', 'o', 'i', 'd' }; |
| |
| // normal case |
| mCanvas.drawTextOnPath(text, 0, 7, new Path(), 10.0f, 10.0f, mPaint); |
| } |
| |
| @Test |
| public void testDrawTextOnPathtestDrawTextRunNegativeCount() { |
| final Path path = new Path(); |
| |
| // no character in text |
| mCanvas.drawTextOnPath("", path, 10.0f, 10.0f, mPaint); |
| |
| // There are characters in text |
| mCanvas.drawTextOnPath("android", path, 10.0f, 10.0f, mPaint); |
| } |
| |
| @Test |
| public void testDrawPicture1() { |
| mCanvas.drawPicture(new Picture()); |
| } |
| |
| @Test |
| public void testDrawPicture2() { |
| final RectF dst = new RectF(0, 0, 10, 31); |
| final Picture p = new Picture(); |
| |
| // picture width or length not bigger than 0 |
| mCanvas.drawPicture(p, dst); |
| |
| p.beginRecording(10, 30); |
| mCanvas.drawPicture(p, dst); |
| } |
| |
| @Test |
| public void testDrawPicture3() { |
| final Rect dst = new Rect(0, 10, 30, 0); |
| final Picture p = new Picture(); |
| |
| // picture width or length not bigger than 0 |
| mCanvas.drawPicture(p, dst); |
| |
| p.beginRecording(10, 30); |
| mCanvas.drawPicture(p, dst); |
| } |
| |
| @Test |
| public void testDensity() { |
| // set Density |
| mCanvas.setDensity(DisplayMetrics.DENSITY_DEFAULT); |
| assertEquals(DisplayMetrics.DENSITY_DEFAULT, mCanvas.getDensity()); |
| |
| // set Density |
| mCanvas.setDensity(DisplayMetrics.DENSITY_HIGH); |
| assertEquals(DisplayMetrics.DENSITY_HIGH, mCanvas.getDensity()); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testDrawHwBitmap_inSwCanvas() { |
| Bitmap hwBitmap = mImmutableBitmap.copy(Config.HARDWARE, false); |
| mCanvas.drawBitmap(hwBitmap, 0, 0, null); // we verify this specific call should IAE |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testDrawHwBitmap_inPictureCanvas_inSwCanvas() { |
| Bitmap hwBitmap = mImmutableBitmap.copy(Config.HARDWARE, false); |
| Picture picture = new Picture(); |
| Canvas pictureCanvas = picture.beginRecording(100, 100); |
| pictureCanvas.drawBitmap(hwBitmap, 0, 0, null); |
| mCanvas.drawPicture(picture); // we verify this specific call should IAE |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testDrawHwBitmap_inPictureCanvas_inPictureCanvas_inSwCanvas() { |
| Bitmap hwBitmap = mImmutableBitmap.copy(Config.HARDWARE, false); |
| Picture innerPicture = new Picture(); |
| Canvas pictureCanvas = innerPicture.beginRecording(100, 100); |
| pictureCanvas.drawBitmap(hwBitmap, 0, 0, null); |
| |
| Picture outerPicture = new Picture(); |
| Canvas outerPictureCanvas = outerPicture.beginRecording(100, 100); |
| outerPictureCanvas.drawPicture(innerPicture); |
| mCanvas.drawPicture(outerPicture); // we verify this specific call should IAE |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testHwBitmapShaderInSwCanvas1() { |
| Bitmap hwBitmap = mImmutableBitmap.copy(Config.HARDWARE, false); |
| BitmapShader bitmapShader = new BitmapShader(hwBitmap, Shader.TileMode.REPEAT, |
| Shader.TileMode.REPEAT); |
| RadialGradient gradientShader = new RadialGradient(10, 10, 30, Color.BLACK, Color.CYAN, |
| Shader.TileMode.REPEAT); |
| Shader shader = new ComposeShader(gradientShader, bitmapShader, Mode.OVERLAY); |
| Paint p = new Paint(); |
| p.setShader(shader); |
| mCanvas.drawRect(0, 0, 10, 10, p); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void testHwBitmapShaderInSwCanvas2() { |
| Bitmap hwBitmap = mImmutableBitmap.copy(Config.HARDWARE, false); |
| BitmapShader bitmapShader = new BitmapShader(hwBitmap, Shader.TileMode.REPEAT, |
| Shader.TileMode.REPEAT); |
| RadialGradient gradientShader = new RadialGradient(10, 10, 30, Color.BLACK, Color.CYAN, |
| Shader.TileMode.REPEAT); |
| Shader shader = new ComposeShader(bitmapShader, gradientShader, Mode.OVERLAY); |
| Paint p = new Paint(); |
| p.setShader(shader); |
| mCanvas.drawRect(0, 0, 10, 10, p); |
| } |
| |
| private void preCompare() { |
| final float[] values = new float[FLOAT_ARRAY_LEN]; |
| mCanvas.getMatrix().getValues(values); |
| assertArrayEquals(new float[] { |
| 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f |
| }, values, 0.0f); |
| } |
| |
| private RectF getDeviceClip() { |
| final RectF clip = new RectF(mCanvas.getClipBounds()); |
| mCanvas.getMatrix().mapRect(clip); |
| return clip; |
| } |
| |
| @Test |
| public void testDrawBitmapColorBehavior() { |
| try { |
| // Create a wide gamut bitmap where the pixel value is slightly less than max red. |
| Resources resources = InstrumentationRegistry.getTargetContext().getResources(); |
| InputStream in = resources.getAssets().open("almost-red-adobe.png"); |
| Bitmap bitmap = BitmapFactory.decodeStream(in); |
| |
| // Draw the bitmap to an sRGB canvas. |
| Bitmap canvasBitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888); |
| Canvas canvas = new Canvas(canvasBitmap); |
| canvas.drawBitmap(bitmap, 0, 0, null); |
| |
| // Verify that the pixel is now max red. |
| Assert.assertEquals(0xFFFF0000, canvasBitmap.getPixel(0, 0)); |
| } catch (IOException e) { |
| fail(); |
| } |
| } |
| |
| @Test |
| public void testShadowLayer_paintColorPreserved() { |
| Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888); |
| Canvas canvas = new Canvas(bitmap); |
| Paint paint = new Paint(); |
| |
| paint.setShadowLayer(5.0f, 10.0f, 10.0f, 0xFFFF0000); |
| paint.setColor(0xFF0000FF); |
| canvas.drawPaint(paint); |
| |
| // Since the shadow is in the background, the canvas should be blue. |
| ColorUtils.verifyColor(0xFF0000FF, bitmap.getPixel(50, 50)); |
| } |
| } |
