android-15.0.0_r3/s

/*
 * Copyright (C) 2018 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.uirendering.cts.testclasses;

import static org.junit.Assert.assertFalse;

import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapShader;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ComposeShader;
import android.graphics.Matrix44;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Picture;
import android.graphics.Point;
import android.graphics.PorterDuff;
import android.graphics.RadialGradient;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.Region;
import android.graphics.Shader;
import android.platform.test.annotations.RequiresFlagsEnabled;
import android.platform.test.flag.junit.CheckFlagsRule;
import android.platform.test.flag.junit.DeviceFlagsValueProvider;
import android.uirendering.cts.R;
import android.uirendering.cts.bitmapverifiers.BitmapVerifier;
import android.uirendering.cts.bitmapverifiers.SamplePointVerifier;
import android.uirendering.cts.testinfrastructure.ActivityTestBase;

import androidx.test.InstrumentationRegistry;
import androidx.test.filters.MediumTest;

import com.android.graphics.hwui.flags.Flags;

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

import junitparams.JUnitParamsRunner;
import junitparams.Parameters;

@MediumTest
@RunWith(JUnitParamsRunner.class)
public class CanvasTests extends ActivityTestBase {

    private static final int PAINT_COLOR = 0xff00ff00;
    private static final int BITMAP_WIDTH = 10;
    private static final int BITMAP_HEIGHT = 28;

    @Rule
    public final CheckFlagsRule mCheckFlagsRule =
            DeviceFlagsValueProvider.createCheckFlagsRule();

    private Paint getPaint() {
        Paint paint = new Paint();
        paint.setColor(PAINT_COLOR);
        return paint;
    }

    public Bitmap getImmutableBitmap() {
        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
        Bitmap immutableBitmap = BitmapFactory.decodeResource(res, R.drawable.sunset1, opt);
        assertFalse(immutableBitmap.isMutable());
        return immutableBitmap;
    }

    public Bitmap getMutableBitmap(Bitmap.Config config) {
        return Bitmap.createBitmap(BITMAP_WIDTH, BITMAP_HEIGHT, config);
    }

    public Bitmap getMutableBitmap() {
        return getMutableBitmap(Bitmap.Config.ARGB_8888);
    }

    @Test
    public void testDrawDoubleRoundRect() {
        Point[] testPoints = {
                new Point(0, 0),
                new Point(89, 0),
                new Point(89, 89),
                new Point(0, 89),
                new Point(10, 10),
                new Point(79, 10),
                new Point(79, 79),
                new Point(10, 79)
        };
        int[] colors = {
                Color.WHITE,
                Color.WHITE,
                Color.WHITE,
                Color.WHITE,
                Color.RED,
                Color.RED,
                Color.RED,
                Color.RED
        };
        createTest()
                .addCanvasClient((canvas, width, height) -> {
                    Paint paint = new Paint();
                    paint.setColor(Color.WHITE);
                    canvas.drawRect(0, 0, width, height, paint);

                    paint.setColor(Color.RED);
                    int inset = 20;
                    RectF outer = new RectF(0, 0, width, height);
                    RectF inner = new RectF(inset,
                            inset,
                            width - inset,
                            height - inset);
                    canvas.drawDoubleRoundRect(outer, 5, 5,
                            inner, 10, 10, paint);
                })
                .runWithVerifier(new SamplePointVerifier(testPoints, colors));
    }

    @Test
    public void testDrawDoubleRoundRectWithRadii() {
        Point[] testPoints = {
                new Point(0, 0),
                new Point(89, 0),
                new Point(89, 89),
                new Point(0, 89),
                new Point(9, 7),
                new Point(81, 7),
                new Point(75, 75),
                new Point(21, 67)
        };
        int[] colors = {
                Color.RED,
                Color.WHITE,
                Color.WHITE,
                Color.WHITE,
                Color.RED,
                Color.RED,
                Color.RED,
                Color.RED
        };
        createTest()
                .addCanvasClient((canvas, width, height) -> {
                    Paint paint = new Paint();
                    paint.setColor(Color.WHITE);
                    canvas.drawRect(0, 0, width, height, paint);

                    paint.setColor(Color.RED);
                    int inset = 30;
                    RectF outer = new RectF(0, 0, width, height);
                    RectF inner = new RectF(inset,
                            inset,
                            width - inset,
                            height - inset);

                    float[] outerRadii = {
                            0.0f, 0.0f, // top left
                            5.0f, 5.0f, // top right
                            10.0f, 10.0f, // bottom right
                            20.0f, 20.0f // bottom left
                    };

                    float[] innerRadii = {
                            20.0f, 20.0f,
                            15.0f, 15.0f,
                            8.0f, 8.0f,
                            3.0f, 3.0f
                    };
                    canvas.drawDoubleRoundRect(outer, outerRadii, inner, innerRadii, paint);
                })
                .runWithVerifier(new SamplePointVerifier(testPoints, colors));
    }

    @RequiresFlagsEnabled(Flags.FLAG_MATRIX_44)
    @Test
    public void testDrawWithConcatenatedMatrix44() {
        Point[] testPoints = {
                new Point(0, 0),
                new Point(45, 45),
                new Point(45, 30),
                new Point(45, 60),
                new Point(20, 45),
                new Point(60, 30),
                new Point(60, 60)

        };
        int[] colors = {
                Color.WHITE,
                Color.RED,
                Color.RED,
                Color.RED,
                Color.RED,
                Color.WHITE,
                Color.WHITE
        };
        createTest()
                .addCanvasClient((canvas, width, height) -> {
                    canvas.drawColor(Color.WHITE);

                    Paint paint = new Paint();
                    paint.setColor(Color.RED);
                    paint.setStyle(Paint.Style.FILL);

                    Matrix44 mat = new Matrix44();
                    // column vector operations are read backwards, so the rect should be centered
                    mat.translate((float) width / 2, (float) height / 2, 0)
                            .rotate(45, 1, 0, 0)
                            .scale(2, 2, 0)
                            .rotate(45, 0, 0, 1);
                    canvas.concat(mat);
                    canvas.drawRect(-10, -10, 10, 10, paint);
                })
                .runWithVerifier(new SamplePointVerifier(testPoints, colors));
    }

    private void drawRotatedBitmap(boolean aa, Canvas canvas, Bitmap.Config config) {
        // create a black bitmap to be drawn to the canvas
        Bitmap bm = getMutableBitmap();
        bm.eraseColor(Color.BLACK);

        // canvas density and bitmap density must match in order for no scaling to occur
        // and aa to be distinguishable from non-aa
        bm.setDensity(canvas.getDensity());

        canvas.drawColor(Color.WHITE);

        Paint aaPaint = new Paint();
        aaPaint.setAntiAlias(aa);

        canvas.rotate(-1.0f, 0, 0);
        canvas.drawBitmap(bm, 0, 0, aaPaint);
    }

    private Object[] testConfigs() {
        return new Object[] {
            Bitmap.Config.ARGB_8888,
            Bitmap.Config.RGBA_1010102
        };
    }

    @Test
    @Parameters(method = "testConfigs")
    public void testDrawRotatedBitmapWithAA(Bitmap.Config config) {
        createTest()
                .addCanvasClient((canvas, width, height) -> {
                    canvas.setDensity(400);
                    drawRotatedBitmap(true, canvas, config);
                })
                // Test asserts there are more than 10 grey pixels.
                .runWithVerifier(AntiAliasPixelCounter.aaVerifier(Color.WHITE, Color.BLACK, 10));
    }

    @Test
    @Parameters(method = "testConfigs")
    public void testDrawRotatedBitmapWithoutAA(Bitmap.Config config) {
        createTest()
                .addCanvasClient((canvas, width, height) -> {
                    canvas.setDensity(400);
                    drawRotatedBitmap(false, canvas, config);
                })
                // Test asserts there are no grey pixels.
                .runWithVerifier(AntiAliasPixelCounter.noAAVerifier(Color.WHITE, Color.BLACK));
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDrawHwBitmap_inSwCanvas() {
        Bitmap hwBitmap = getImmutableBitmap().copy(Bitmap.Config.HARDWARE, false);
        // we verify this specific call should IAE
        new Canvas(getMutableBitmap()).drawBitmap(hwBitmap, 0, 0, null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDrawHwBitmap_inPictureCanvas_inSwCanvas() {
        Bitmap hwBitmap = getImmutableBitmap().copy(Bitmap.Config.HARDWARE, false);
        Picture picture = new Picture();
        Canvas pictureCanvas = picture.beginRecording(100, 100);
        pictureCanvas.drawBitmap(hwBitmap, 0, 0, null);
        // we verify this specific call should IAE
        new Canvas(getMutableBitmap()).drawPicture(picture);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDrawHwBitmap_inPictureCanvas_inPictureCanvas_inSwCanvas() {
        Bitmap hwBitmap = getImmutableBitmap().copy(Bitmap.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);
        // we verify this specific call should IAE
        new Canvas(getMutableBitmap()).drawPicture(outerPicture);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testHwBitmapShaderInSwCanvas1() {
        Bitmap hwBitmap = getImmutableBitmap().copy(Bitmap.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, PorterDuff.Mode.OVERLAY);
        Paint p = new Paint();
        p.setShader(shader);
        new Canvas(getMutableBitmap()).drawRect(0, 0, 10, 10, p);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testHwBitmapShaderInSwCanvas2() {
        Bitmap hwBitmap = getImmutableBitmap().copy(Bitmap.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, PorterDuff.Mode.OVERLAY);
        Paint p = new Paint();
        p.setShader(shader);
        new Canvas(getMutableBitmap()).drawRect(0, 0, 10, 10, p);
    }

    @Test(expected = IllegalStateException.class)
    public void testCanvasFromImmutableBitmap() {
        // Should throw out IllegalStateException when creating Canvas with an ImmutableBitmap
        new Canvas(getImmutableBitmap());
    }

    @Test(expected = RuntimeException.class)
    public void testCanvasFromRecycledBitmap() {
        // Should throw out RuntimeException when creating Canvas with a MutableBitmap which
        // is recycled
        Bitmap bitmap = getMutableBitmap();
        bitmap.recycle();
        new Canvas(bitmap);
    }

    @Test(expected = IllegalStateException.class)
    public void testSetBitmapToImmutableBitmap() {
        // Should throw out IllegalStateException when setting an ImmutableBitmap to a Canvas
        new Canvas(getMutableBitmap()).setBitmap(getImmutableBitmap());
    }

    @Test(expected = RuntimeException.class)
    public void testSetBitmapToRecycledBitmap() {
        // Should throw out RuntimeException when setting Bitmap which is recycled to a Canvas
        Bitmap bitmap = getMutableBitmap();
        bitmap.recycle();
        new Canvas(getMutableBitmap()).setBitmap(bitmap);
    }

    @Test(expected = IllegalStateException.class)
    public void testRestoreWithoutSave() {
        // Should throw out IllegalStateException because cannot restore Canvas before save
        new Canvas(getMutableBitmap()).restore();
    }

    @Test(expected = IllegalArgumentException.class)
    public void testRestoreToCountIllegalSaveCount() {
        // Should throw out IllegalArgumentException because saveCount is less than 1
        new Canvas(getMutableBitmap()).restoreToCount(0);
    }

    @Test(expected = ArrayIndexOutOfBoundsException.class)
    public void testDrawPointsInvalidOffset() {
        // Should throw out ArrayIndexOutOfBoundsException because of invalid offset
        new Canvas(getMutableBitmap()).drawPoints(new float[]{
                10.0f, 29.0f
        }, -1, 2, getPaint());
    }

    @Test(expected = ArrayIndexOutOfBoundsException.class)
    public void testDrawPointsInvalidCount() {
        // Should throw out ArrayIndexOutOfBoundsException because of invalid count
        new Canvas(getMutableBitmap()).drawPoints(new float[]{
                10.0f, 29.0f
        }, 0, 31, getPaint());
    }

    @Test(expected = ArrayIndexOutOfBoundsException.class)
    public void testDrawLinesInvalidOffset() {
        // Should throw out ArrayIndexOutOfBoundsException because of invalid offset
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).drawLines(new float[]{
                0, 0, 10, 31
        }, 0, 8, new Paint());
    }

    @Test(expected = NullPointerException.class)
    public void testDrawOvalNull() {
        // Should throw out NullPointerException because oval is null
        new Canvas(getMutableBitmap()).drawOval(null, getPaint());
    }

    @Test(expected = NullPointerException.class)
    public void testDrawArcNullOval() {
        // Should throw NullPointerException because oval is null
        new Canvas(getMutableBitmap()).drawArc(null, 10.0f, 29.0f,
                true, getPaint());
    }

    @Test(expected = NullPointerException.class)
    public void testDrawRoundRectNull() {
        // Should throw out NullPointerException because RoundRect is null
        new Canvas(getMutableBitmap()).drawRoundRect(null, 10.0f, 29.0f, getPaint());
    }

    @Test(expected = RuntimeException.class)
    public void testDrawBitmapAtPointRecycled() {
        Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Bitmap.Config.ARGB_8888);
        b.recycle();

        // Should throw out RuntimeException because bitmap has been recycled
        new Canvas(getMutableBitmap()).drawBitmap(b, 10.0f, 29.0f, getPaint());
    }

    @Test(expected = RuntimeException.class)
    public void testDrawBitmapSrcDstFloatRecycled() {
        Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Bitmap.Config.ARGB_8888);
        b.recycle();

        // Should throw out RuntimeException because bitmap has been recycled
        new Canvas(getMutableBitmap()).drawBitmap(b, null, new RectF(), getPaint());
    }

    @Test(expected = RuntimeException.class)
    public void testDrawBitmapSrcDstIntRecycled() {
        Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Bitmap.Config.ARGB_8888);
        b.recycle();

        // Should throw out RuntimeException because bitmap has been recycled
        new Canvas(getMutableBitmap()).drawBitmap(b, null, new Rect(), getPaint());
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDrawBitmapIntsNegativeWidth() {
        // Should throw out IllegalArgumentException because width is less than 0
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).drawBitmap(new int[29], 10, 29, 10,
                10, 20, 10, true, null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testDrawBitmapFloatsNegativeWidth() {
        // Should throw out IllegalArgumentException because width is less than 0
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).drawBitmap(new int[29], 10, 29, 10.0f,
                10.0f, 20, 10, true, null);
    }

    @Test(expected = ArrayIndexOutOfBoundsException.class)
    public void testDrawBitmapMeshNegativeWidth() {
        final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Bitmap.Config.ARGB_8888);

        // Should throw out ArrayIndexOutOfBoundsException because meshWidth less than 0
        new Canvas(getMutableBitmap()).drawBitmapMesh(b, -1, 10,
                null, 0, null, 0, null);
    }

    @Test(expected = ArrayIndexOutOfBoundsException.class)
    public void testDrawBitmapMeshNegativeHeight() {
        final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Bitmap.Config.ARGB_8888);

        // Should throw out ArrayIndexOutOfBoundsException because meshHeight is less than 0
        new Canvas(getMutableBitmap()).drawBitmapMesh(b, 10, -1,
                null, 0, null, 0, null);
    }

    @Test(expected = ArrayIndexOutOfBoundsException.class)
    public void testDrawBitmapMeshNegativeVertOffset() {
        final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Bitmap.Config.ARGB_8888);

        // Should throw out ArrayIndexOutOfBoundsException because vertOffset is less than 0
        new Canvas(getMutableBitmap()).drawBitmapMesh(b, 10, 10,
                null, -1, null, 0, null);
    }

    @Test(expected = ArrayIndexOutOfBoundsException.class)
    public void testDrawBitmapMeshNegativeColorOffset() {
        final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Bitmap.Config.ARGB_8888);

        // Should throw out ArrayIndexOutOfBoundsException because colorOffset is less than 0
        new Canvas(getMutableBitmap()).drawBitmapMesh(b, 10, 10,
                null, 10, null, -1, null);
    }

    @Test(expected = ArrayIndexOutOfBoundsException.class)
    public void testDrawBitmapMeshTooFewVerts() {
        final Bitmap b = Bitmap.createBitmap(BITMAP_WIDTH, 29, Bitmap.Config.ARGB_8888);

        // Should throw out ArrayIndexOutOfBoundsException because verts' length is too short
        new Canvas(getMutableBitmap()).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, Bitmap.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];
        new Canvas(getMutableBitmap()).drawBitmapMesh(b, 10, 10, verts,
                10, new int[] { 10, 29}, 10, null);
    }

    @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
        new Canvas(getMutableBitmap()).drawVertices(Canvas.VertexMode.TRIANGLES, 10,
                verts, 8, texs, 0, colors, 0, indices,
                0, 4, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawVertices(Canvas.VertexMode.TRIANGLES, 10,
                verts, 0, texs, 30, colors, 0, indices,
                0, 4, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawVertices(Canvas.VertexMode.TRIANGLES, 10,
                verts, 0, texs, 0, colors, 30, indices,
                0, 4, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawVertices(Canvas.VertexMode.TRIANGLES, 10,
                verts, 0, texs, 0, colors, 0, indices,
                10, 30, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawText(text, -1, 7, 10, 10, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawText(text, 0, -1, 10, 10, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawText(text, 0, 10, 10, 10, getPaint());
    }

    @Test(expected = IndexOutOfBoundsException.class)
    public void testDrawTextTextAtPositionWithOffsetsNegativeStart() {
        // Should throw out IndexOutOfBoundsException because start is less than 0
        new Canvas(getMutableBitmap()).drawText("android", -1, 7, 10, 30,
                getPaint());
    }

    @Test(expected = IndexOutOfBoundsException.class)
    public void testDrawTextTextAtPositionWithOffsetsNegativeEnd() {
        // Should throw out IndexOutOfBoundsException because end is less than 0
        new Canvas(getMutableBitmap()).drawText("android", 0, -1, 10, 30,
                getPaint());
    }

    @Test(expected = IndexOutOfBoundsException.class)
    public void testDrawTextTextAtPositionWithOffsetsStartEndMismatch() {
        // Should throw out IndexOutOfBoundsException because start is bigger than end
        new Canvas(getMutableBitmap()).drawText("android", 3, 1, 10, 30,
                getPaint());
    }

    @Test(expected = IndexOutOfBoundsException.class)
    public void testDrawTextTextAtPositionWithOffsetsTextTooLong() {
        // Should throw out IndexOutOfBoundsException because end subtracts start should
        // bigger than text's length
        new Canvas(getMutableBitmap()).drawText("android", 0, 10, 10, 30,
                getPaint());
    }

    @Test(expected = NullPointerException.class)
    public void testDrawTextRunNullCharArray() {
        // Should throw out NullPointerException because text is null
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).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
        new Canvas(getMutableBitmap()).drawPosText(text, -1, 7, pos, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawPosText(text, 1, 10, pos, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawPosText(text, 1, 10, new float[] {
                10.0f, 30.f
        }, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawTextOnPath(text, -1, 7, new Path(),
                10.0f, 10.0f, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawTextOnPath(text, 0, 10, new Path(),
                10.0f, 10.0f, getPaint());
    }

    @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
        new Canvas(getMutableBitmap()).drawPosText(text, new float[]{
                10.0f, 30.f
        }, getPaint());
    }

    @Test
    public void testClipIntersectAndDifference() {
        Point[] testPoints = {
            new Point(1, 1),
            new Point(10, 10),
            new Point(25, 25)
        };
        int[] colors = {
            Color.WHITE,
            Color.RED,
            Color.GREEN
        };
        createTest()
                .addCanvasClient((canvas, width, height) -> {
                    // Base is white
                    Paint paint = new Paint();
                    paint.setColor(Color.WHITE);
                    canvas.drawRect(0, 0, width, height, paint);

                    // Fill inset with green, which will later be overwitten with
                    // red except for a subsequent difference clip op
                    canvas.clipRect(5, 5, width - 5, height - 5);
                    paint.setColor(Color.GREEN);
                    canvas.drawRect(0, 0, width, height, paint);

                    // Cut out the inner region, so that it remains green
                    canvas.clipOutRect(20, 20, width - 20, height - 20);
                    paint.setColor(Color.RED);
                    canvas.drawRect(0, 0, width, height, paint);
                })
                .runWithVerifier(new SamplePointVerifier(testPoints, colors));
    }

    // Expanding region ops (replace, reverse diff, union, and xor) are not allowed for clipping
    @Test(expected = IllegalArgumentException.class)
    public void testClipReplace() {
        new Canvas(getMutableBitmap()).clipRect(0, 0, 10, 10, Region.Op.REPLACE);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testClipReverseDifference() {
        new Canvas(getMutableBitmap()).clipRect(0, 0, 10, 10, Region.Op.REVERSE_DIFFERENCE);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testClipUnion() {
        new Canvas(getMutableBitmap()).clipRect(0, 0, 10, 10, Region.Op.UNION);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testClipXor() {
        new Canvas(getMutableBitmap()).clipRect(0, 0, 10, 10, Region.Op.XOR);
    }

    @Test
    public void testAntiAliasClipping() {
        createTest()
                .addCanvasClient((canvas, width, height) -> {
                    Paint paint = new Paint();
                    Path clipPath = new Path();

                    clipPath.addCircle(
                            width / 2.0f, height / 2.0f,
                            Math.min(width, height) / 2.0f,
                            Path.Direction.CW
                    );

                    paint.setColor(Color.WHITE);
                    canvas.drawRect(0, 0, width, height, paint);

                    paint.setColor(Color.RED);

                    canvas.save();

                    canvas.clipPath(clipPath);
                    canvas.drawRect(0, 0, width, height, paint);

                    canvas.restore();

                })
                .runWithVerifier(AntiAliasPixelCounter.aaVerifier(Color.WHITE, Color.RED, 10));
    }

    private static class AntiAliasPixelCounter extends BitmapVerifier {

        private final int mColor1;
        private final int mColor2;
        private final int mCountThreshold;
        // when true mCountThreshold is treated as a maximum
        // when false mCountThreshold is treated as a minimum
        private final boolean mThresholdIsAMaxium;

        // factory method for a verifier that confirms some non-target-color pixels are present
        // this is only a verification that aa has occurred if a single solid color shape has been
        // drawn on a solid background with at least one one visible edge, and every other possible
        // thing that can change the colors has been disabled.
        public static AntiAliasPixelCounter aaVerifier(int color1, int color2, int countThreshold) {
            return new AntiAliasPixelCounter(color1, color2, countThreshold, false);
        }
        // factory method for a verifier that confirms only target color pixels are present.
        public static AntiAliasPixelCounter noAAVerifier(int color1, int color2) {
            return new AntiAliasPixelCounter(color1, color2, 0, true);
        }

        AntiAliasPixelCounter(int color1, int color2, int countThreshold, boolean thresholdIsMax) {
            mColor1 = color1;
            mColor2 = color2;
            mCountThreshold = countThreshold;
            mThresholdIsAMaxium = thresholdIsMax;
        }

        @Override
        public boolean verify(int[] bitmap, int offset, int stride, int width, int height) {
            int nonTargetColorCount = 0;
            for (int x = 0; x < width; x++) {
                for (int y = 0; y < height; y++) {
                    int pixelColor = bitmap[indexFromXAndY(x, y, stride, offset)];
                    if (pixelColor != mColor1 && pixelColor != mColor2) {
                        nonTargetColorCount++;
                    }
                }
            }
            if (mThresholdIsAMaxium) {
                return nonTargetColorCount <= mCountThreshold;
            } else {
                return nonTargetColorCount > mCountThreshold;
            }
        }
    }
}