/*
 * 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.drawable.cts;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import android.content.res.Resources;
import android.content.res.Resources.Theme;
import android.content.res.XmlResourceParser;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ColorFilter;
import android.graphics.NinePatch;
import android.graphics.Outline;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.PorterDuff.Mode;
import android.graphics.Rect;
import android.graphics.Region;
import android.graphics.cts.R;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.Drawable.ConstantState;
import android.graphics.drawable.NinePatchDrawable;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.Xml;

import androidx.test.InstrumentationRegistry;
import androidx.test.filters.SmallTest;
import androidx.test.runner.AndroidJUnit4;

import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

@SmallTest
@RunWith(AndroidJUnit4.class)
public class NinePatchDrawableTest {
    // A small value is actually making sure that the values are matching
    // exactly with the golden image.
    // We can increase the threshold if the Skia is drawing with some variance
    // on different devices. So far, the tests show they are matching correctly.
    private static final float PIXEL_ERROR_THRESHOLD = 0.03f;
    private static final float PIXEL_ERROR_COUNT_THRESHOLD = 0.005f;

    private static final int MIN_CHUNK_SIZE = 32;

    // Set true to generate golden images, false for normal tests.
    private static final boolean DBG_DUMP_PNG = false;

    private NinePatchDrawable mNinePatchDrawable;

    private Resources mResources;

    @Before
    public void setup() {
        mResources = InstrumentationRegistry.getTargetContext().getResources();
        mNinePatchDrawable = getNinePatchDrawable(R.drawable.ninepatch_0);
    }

    @SuppressWarnings("deprecation")
    @Test
    public void testConstructors() {
        byte[] chunk = new byte[MIN_CHUNK_SIZE];
        chunk[MIN_CHUNK_SIZE - 1] = 1;

        Rect r = new Rect();

        Bitmap bmp = BitmapFactory.decodeResource(mResources, R.drawable.ninepatch_0);
        String name = mResources.getResourceName(R.drawable.ninepatch_0);

        new NinePatchDrawable(bmp, chunk, r, name);

        new NinePatchDrawable(new NinePatch(bmp, chunk, name));

        chunk = new byte[MIN_CHUNK_SIZE - 1];
        chunk[MIN_CHUNK_SIZE - 2] = 1;
        try {
            new NinePatchDrawable(bmp, chunk, r, name);
            fail("The constructor should check whether the chunk is illegal.");
        } catch (RuntimeException e) {
            // This exception is thrown by native method.
        }
    }

    @Test
    public void testDraw() {
        Bitmap bmp = Bitmap.createBitmap(9, 9, Config.ARGB_8888);
        Canvas c = new Canvas(bmp);

        int ocean = Color.rgb(0, 0xFF, 0x80);

        mNinePatchDrawable.setBounds(0, 0, 9, 9);
        mNinePatchDrawable.draw(c);
        verifyColorFillRect(bmp, 0, 0, 4, 4, Color.RED);
        verifyColorFillRect(bmp, 5, 0, 4, 4, Color.BLUE);
        verifyColorFillRect(bmp, 0, 5, 4, 4, ocean);
        verifyColorFillRect(bmp, 5, 5, 4, 4, Color.YELLOW);
        verifyColorFillRect(bmp, 4, 0, 1, 9, Color.WHITE);
        verifyColorFillRect(bmp, 0, 4, 9, 1, Color.WHITE);

        bmp.eraseColor(0xff000000);

        mNinePatchDrawable.setBounds(0, 0, 3, 3);
        mNinePatchDrawable.draw(c);
        verifyColorFillRect(bmp, 0, 0, 1, 1, Color.RED);
        verifyColorFillRect(bmp, 2, 0, 1, 1, Color.BLUE);
        verifyColorFillRect(bmp, 0, 2, 1, 1, ocean);
        verifyColorFillRect(bmp, 2, 2, 1, 1, Color.YELLOW);
        verifyColorFillRect(bmp, 1, 0, 1, 3, Color.WHITE);
        verifyColorFillRect(bmp, 0, 1, 3, 1, Color.WHITE);
    }

    @Test(expected=NullPointerException.class)
    public void testDrawNullCanvas() {
        mNinePatchDrawable.draw(null);
    }

    @Test
    public void testGetChangingConfigurations() {
        ConstantState constantState = mNinePatchDrawable.getConstantState();

        // default
        assertEquals(0, constantState.getChangingConfigurations());
        assertEquals(0, mNinePatchDrawable.getChangingConfigurations());

        // change the drawable's configuration does not affect the state's configuration
        mNinePatchDrawable.setChangingConfigurations(0xff);
        assertEquals(0xff, mNinePatchDrawable.getChangingConfigurations());
        assertEquals(0, constantState.getChangingConfigurations());

        // the state's configuration get refreshed
        constantState = mNinePatchDrawable.getConstantState();
        assertEquals(0xff,  constantState.getChangingConfigurations());

        // set a new configuration to drawable
        mNinePatchDrawable.setChangingConfigurations(0xff00);
        assertEquals(0xff,  constantState.getChangingConfigurations());
        assertEquals(0xffff,  mNinePatchDrawable.getChangingConfigurations());
    }

    @Test
    public void testGetPadding() {
        Rect r = new Rect();
        NinePatchDrawable npd = (NinePatchDrawable) mResources.getDrawable(R.drawable.ninepatch_0);
        assertTrue(npd.getPadding(r));
        // exact padding unknown due to possible density scaling
        assertEquals(0, r.left);
        assertEquals(0, r.top);
        assertTrue(r.right > 0);
        assertTrue(r.bottom > 0);

        npd = (NinePatchDrawable) mResources.getDrawable(R.drawable.ninepatch_1);
        assertTrue(npd.getPadding(r));
        assertTrue(r.left > 0);
        assertTrue(r.top > 0);
        assertTrue(r.right > 0);
        assertTrue(r.bottom > 0);
    }

    @Test
    public void testSetAlpha() {
        assertEquals(0xff, mNinePatchDrawable.getPaint().getAlpha());

        mNinePatchDrawable.setAlpha(0);
        assertEquals(0, mNinePatchDrawable.getPaint().getAlpha());

        mNinePatchDrawable.setAlpha(-1);
        assertEquals(0xff, mNinePatchDrawable.getPaint().getAlpha());

        mNinePatchDrawable.setAlpha(0xfffe);
        assertEquals(0xfe, mNinePatchDrawable.getPaint().getAlpha());
    }

    @Test
    public void testSetColorFilter() {
        assertNull(mNinePatchDrawable.getPaint().getColorFilter());

        ColorFilter cf = new ColorFilter();
        mNinePatchDrawable.setColorFilter(cf);
        assertSame(cf, mNinePatchDrawable.getPaint().getColorFilter());

        mNinePatchDrawable.setColorFilter(null);
        assertNull(mNinePatchDrawable.getPaint().getColorFilter());
    }

    @Test
    public void testSetTint() {
        mNinePatchDrawable.setTint(Color.BLACK);
        mNinePatchDrawable.setTintMode(Mode.SRC_OVER);
        assertEquals("Nine-patch is tinted", Color.BLACK,
                DrawableTestUtils.getPixel(mNinePatchDrawable, 0, 0));

        mNinePatchDrawable.setTintList(null);
        mNinePatchDrawable.setTintMode(null);
    }

    @Test
    public void testSetDither() {
        mNinePatchDrawable.setDither(false);
        assertFalse(mNinePatchDrawable.getPaint().isDither());

        mNinePatchDrawable.setDither(true);
        assertTrue(mNinePatchDrawable.getPaint().isDither());
    }

    @Test
    public void testSetFilterBitmap() {
        mNinePatchDrawable.setFilterBitmap(false);
        assertFalse(mNinePatchDrawable.getPaint().isFilterBitmap());

        mNinePatchDrawable.setFilterBitmap(true);
        assertTrue(mNinePatchDrawable.getPaint().isFilterBitmap());
    }

    @Test
    public void testIsFilterBitmap() {
        mNinePatchDrawable.setFilterBitmap(false);
        assertFalse(mNinePatchDrawable.isFilterBitmap());
        assertEquals(mNinePatchDrawable.isFilterBitmap(),
                mNinePatchDrawable.getPaint().isFilterBitmap());


        mNinePatchDrawable.setFilterBitmap(true);
        assertTrue(mNinePatchDrawable.isFilterBitmap());
        assertEquals(mNinePatchDrawable.isFilterBitmap(),
                mNinePatchDrawable.getPaint().isFilterBitmap());
    }

    @Test
    public void testGetPaint() {
        Paint paint = mNinePatchDrawable.getPaint();
        assertNotNull(paint);

        assertSame(paint, mNinePatchDrawable.getPaint());
    }

    @Test
    public void testGetIntrinsicWidth() {
        Bitmap bmp = getBitmapUnscaled(R.drawable.ninepatch_0);
        assertEquals(bmp.getWidth(), mNinePatchDrawable.getIntrinsicWidth());
        assertEquals(5, mNinePatchDrawable.getIntrinsicWidth());

        mNinePatchDrawable = getNinePatchDrawable(R.drawable.ninepatch_1);
        bmp = getBitmapUnscaled(R.drawable.ninepatch_1);
        assertEquals(bmp.getWidth(), mNinePatchDrawable.getIntrinsicWidth());
        assertEquals(9, mNinePatchDrawable.getIntrinsicWidth());
    }

    @Test
    public void testGetMinimumWidth() {
        Bitmap bmp = getBitmapUnscaled(R.drawable.ninepatch_0);
        assertEquals(bmp.getWidth(), mNinePatchDrawable.getMinimumWidth());
        assertEquals(5, mNinePatchDrawable.getMinimumWidth());

        mNinePatchDrawable = getNinePatchDrawable(R.drawable.ninepatch_1);
        bmp = getBitmapUnscaled(R.drawable.ninepatch_1);
        assertEquals(bmp.getWidth(), mNinePatchDrawable.getMinimumWidth());
        assertEquals(9, mNinePatchDrawable.getMinimumWidth());
    }

    @Test
    public void testGetIntrinsicHeight() {
        Bitmap bmp = getBitmapUnscaled(R.drawable.ninepatch_0);
        assertEquals(bmp.getHeight(), mNinePatchDrawable.getIntrinsicHeight());
        assertEquals(5, mNinePatchDrawable.getIntrinsicHeight());

        mNinePatchDrawable = getNinePatchDrawable(R.drawable.ninepatch_1);
        bmp = getBitmapUnscaled(R.drawable.ninepatch_1);
        assertEquals(bmp.getHeight(), mNinePatchDrawable.getIntrinsicHeight());
        assertEquals(9, mNinePatchDrawable.getIntrinsicHeight());
    }

    @Test
    public void testGetMinimumHeight() {
        Bitmap bmp = getBitmapUnscaled(R.drawable.ninepatch_0);
        assertEquals(bmp.getHeight(), mNinePatchDrawable.getMinimumHeight());
        assertEquals(5, mNinePatchDrawable.getMinimumHeight());

        mNinePatchDrawable = getNinePatchDrawable(R.drawable.ninepatch_1);
        bmp = getBitmapUnscaled(R.drawable.ninepatch_1);
        assertEquals(bmp.getHeight(), mNinePatchDrawable.getMinimumHeight());
        assertEquals(9, mNinePatchDrawable.getMinimumHeight());
    }

    // Known failure: Bug 2834281 - Bitmap#hasAlpha seems to return true for
    // images without alpha
    @Ignore
    @Test
    public void testGetOpacity() {
        assertEquals(PixelFormat.OPAQUE, mNinePatchDrawable.getOpacity());

        mNinePatchDrawable = getNinePatchDrawable(R.drawable.ninepatch_1);
        assertEquals(PixelFormat.TRANSLUCENT, mNinePatchDrawable.getOpacity());
    }

    @Test
    public void testGetTransparentRegion() {
        // opaque image
        Region r = mNinePatchDrawable.getTransparentRegion();
        assertNull(r);

        mNinePatchDrawable.setBounds(0, 0, 7, 7);
        r = mNinePatchDrawable.getTransparentRegion();
        assertNull(r);

        // translucent image
        mNinePatchDrawable = getNinePatchDrawable(R.drawable.ninepatch_1);
        r = mNinePatchDrawable.getTransparentRegion();
        assertNull(r);

        mNinePatchDrawable.setBounds(1, 1, 7, 7);
        r = mNinePatchDrawable.getTransparentRegion();
        assertNotNull(r);
        assertEquals(new Rect(1, 1, 7, 7), r.getBounds());
    }

    @Test
    public void testGetConstantState() {
        assertNotNull(mNinePatchDrawable.getConstantState());

        ConstantState constantState = mNinePatchDrawable.getConstantState();
        // change the drawable's configuration does not affect the state's configuration
        mNinePatchDrawable.setChangingConfigurations(0xff);
        assertEquals(0, constantState.getChangingConfigurations());
        // the state's configuration refreshed when getConstantState is called.
        constantState = mNinePatchDrawable.getConstantState();
        assertEquals(0xff, constantState.getChangingConfigurations());
    }

    @Test
    public void testInflate() throws XmlPullParserException, IOException {
        int sourceWidth = 80;
        int sourceHeight = 120;
        int[] colors = new int[sourceWidth * sourceHeight];
        Bitmap bitmap = Bitmap.createBitmap(
                colors, sourceWidth, sourceHeight, Bitmap.Config.RGB_565);
        NinePatchDrawable ninePatchDrawable = new NinePatchDrawable(
                mResources, bitmap, new byte[1000], null, "TESTNAME");

        int sourceDensity = bitmap.getDensity();
        int targetDensity = mResources.getDisplayMetrics().densityDpi;
        int targetWidth = DrawableTestUtils.scaleBitmapFromDensity(
                sourceWidth, sourceDensity, targetDensity);
        int targetHeight = DrawableTestUtils.scaleBitmapFromDensity(
                sourceHeight, sourceDensity, targetDensity);
        assertEquals(targetWidth, ninePatchDrawable.getIntrinsicWidth());
        assertEquals(targetHeight, ninePatchDrawable.getIntrinsicHeight());

        XmlResourceParser parser = mResources.getXml(R.drawable.ninepatchdrawable);
        int type;
        while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
                && type != XmlPullParser.START_TAG) {
        }
        AttributeSet attrs = Xml.asAttributeSet(parser);
        ninePatchDrawable.inflate(mResources, parser, attrs);

        assertTrue(ninePatchDrawable.getPaint().isDither());
        assertTrue(sourceHeight != ninePatchDrawable.getIntrinsicHeight());
        assertTrue(sourceWidth != ninePatchDrawable.getIntrinsicWidth());
    }

    @Test
    public void testMutate() {
        NinePatchDrawable d1 =
            (NinePatchDrawable) mResources.getDrawable(R.drawable.ninepatchdrawable);
        NinePatchDrawable d2 =
            (NinePatchDrawable) mResources.getDrawable(R.drawable.ninepatchdrawable);
        NinePatchDrawable d3 =
            (NinePatchDrawable) mResources.getDrawable(R.drawable.ninepatchdrawable);

        // the state is not shared before mutate.
        d1.setDither(false);
        assertFalse(d1.getPaint().isDither());
        assertTrue(d2.getPaint().isDither());
        assertTrue(d3.getPaint().isDither());

        // cannot test if mutate worked, since state was not shared before
        d1.mutate();
    }

    private static final int[] DENSITY_VALUES = new int[] {
            160, 80, 320
    };

    private static final int[] DENSITY_IMAGES = new int[] {
            R.drawable.nine_patch_density
    };

    private static final int[][] DENSITY_GOLDEN_IMAGES = new int[][] {
            {
                    R.drawable.nine_patch_density_golden_160,
                    R.drawable.nine_patch_density_golden_80,
                    R.drawable.nine_patch_density_golden_320,
            }
    };

    private interface TargetDensitySetter {
        void setTargetDensity(NinePatchDrawable dr, int density);
    }

    private void verifySetTargetDensityOuter(TargetDensitySetter densitySetter) {
        final Resources res = mResources;
        final int densityDpi = res.getConfiguration().densityDpi;
        try {
            verifySetTargetDensityInner(res, DENSITY_IMAGES[0], DENSITY_VALUES, densitySetter);
        } catch (IOException | XmlPullParserException e) {
            throw new RuntimeException(e);
        } finally {
            DrawableTestUtils.setResourcesDensity(res, densityDpi);
        }
    }

    private void verifySetTargetDensityInner(Resources res, int sourceResId, int[] densities,
            TargetDensitySetter densitySetter) throws XmlPullParserException, IOException {
        final Rect tempPadding = new Rect();

        // Capture initial state at preload density.
        final int preloadDensityDpi = densities[0];
        DrawableTestUtils.setResourcesDensity(res, preloadDensityDpi);

        final NinePatchDrawable preloadedDrawable =
                (NinePatchDrawable) res.getDrawable(sourceResId).mutate();
        final int origWidth = preloadedDrawable.getIntrinsicWidth();
        final int origHeight = preloadedDrawable.getIntrinsicHeight();
        final Rect origPadding = new Rect();
        preloadedDrawable.getPadding(origPadding);

        for (int i = 1; i < densities.length; i++) {
            final int scaledDensityDpi = densities[i];
            final float scale = scaledDensityDpi / (float) preloadDensityDpi;

            final NinePatchDrawable scaledDrawable =
                    (NinePatchDrawable) res.getDrawable(sourceResId).mutate();
            densitySetter.setTargetDensity(scaledDrawable, scaledDensityDpi);

            // Sizes are rounded.
            assertEquals(Math.round(origWidth * scale), scaledDrawable.getIntrinsicWidth());
            assertEquals(Math.round(origHeight * scale), scaledDrawable.getIntrinsicHeight());

            // Padding is truncated.
            assertTrue(scaledDrawable.getPadding(tempPadding));
            assertEquals((int) (origPadding.left * scale), tempPadding.left);
            assertEquals((int) (origPadding.top * scale), tempPadding.top);
            assertEquals((int) (origPadding.right * scale), tempPadding.right);
            assertEquals((int) (origPadding.bottom * scale), tempPadding.bottom);

            // Ensure theme density is applied correctly. Unlike most
            // drawables, we don't have any loss of accuracy because density
            // changes are re-computed from the source every time.
            DrawableTestUtils.setResourcesDensity(res, preloadDensityDpi);

            final Theme t = res.newTheme();
            scaledDrawable.applyTheme(t);
            assertEquals(origWidth, scaledDrawable.getIntrinsicWidth());
            assertEquals(origHeight, scaledDrawable.getIntrinsicHeight());
            assertTrue(scaledDrawable.getPadding(tempPadding));
            assertEquals(origPadding, tempPadding);
        }
    }

    @Test
    public void testSetTargetDensity() {
        verifySetTargetDensityOuter((dr, density) -> dr.setTargetDensity(density));
    }

    @Test
    public void testSetTargetDensity_Canvas() {
        // This should be identical to calling setTargetDensity(int) with the
        // value returned by Canvas.getDensity().
        verifySetTargetDensityOuter((dr, density) -> {
            Canvas c = new Canvas();
            c.setDensity(density);
            dr.setTargetDensity(c);
        });
    }

    @Test
    public void testSetTargetDensity_DisplayMetrics() {
        // This should be identical to calling setTargetDensity(int) with the
        // value of DisplayMetrics.densityDpi.
        verifySetTargetDensityOuter((dr, density) -> {
            DisplayMetrics dm = new DisplayMetrics();
            dm.densityDpi = density;
            dr.setTargetDensity(dm);
        });
    }

    @Test
    public void testPreloadDensity() throws XmlPullParserException, IOException {
        final Resources res = mResources;
        final int densityDpi = res.getConfiguration().densityDpi;
        try {
            verifyPreloadDensityInner(res, DENSITY_IMAGES[0], DENSITY_VALUES,
                    DENSITY_GOLDEN_IMAGES[0]);
        } finally {
            DrawableTestUtils.setResourcesDensity(res, densityDpi);
        }
    }

    private void verifyPreloadDensityInner(Resources res, int sourceResId, int[] densities,
            int[] goldenResIds) throws XmlPullParserException, IOException {
        // Capture initial state at preload density.
        final int preloadDensityDpi = densities[0];
        final NinePatchDrawable preloadedDrawable = preloadedDrawable(res,
                densities[0], sourceResId);

        final ConstantState preloadedConstantState = preloadedDrawable.getConstantState();
        final int origWidth = preloadedDrawable.getIntrinsicWidth();
        final int origHeight = preloadedDrawable.getIntrinsicHeight();
        final Rect origPadding = new Rect();
        preloadedDrawable.getPadding(origPadding);

        compareOrSave(preloadedDrawable, preloadDensityDpi, sourceResId, goldenResIds[0]);

        for (int i = 1; i < densities.length; i++) {
            final int scaledDensityDpi = densities[i];
            final float scale = scaledDensityDpi / (float) preloadDensityDpi;
            DrawableTestUtils.setResourcesDensity(res, scaledDensityDpi);

            final NinePatchDrawable scaledDrawable =
                    (NinePatchDrawable) preloadedConstantState.newDrawable(res);

            assertEquals(Math.round(origWidth * scale), scaledDrawable.getIntrinsicWidth());
            assertEquals(Math.round(origHeight * scale), scaledDrawable.getIntrinsicHeight());

            // Padding is truncated.
            final Rect tempPadding = new Rect();
            assertTrue(scaledDrawable.getPadding(tempPadding));
            assertEquals((int) (origPadding.left * scale), tempPadding.left);
            assertEquals((int) (origPadding.top * scale), tempPadding.top);
            assertEquals((int) (origPadding.right * scale), tempPadding.right);
            assertEquals((int) (origPadding.bottom * scale), tempPadding.bottom);

            compareOrSave(scaledDrawable, scaledDensityDpi, sourceResId, goldenResIds[i]);

            // Ensure theme density is applied correctly. Unlike most
            // drawables, we don't have any loss of accuracy because density
            // changes are re-computed from the source every time.
            DrawableTestUtils.setResourcesDensity(res, preloadDensityDpi);

            final Theme t = res.newTheme();
            scaledDrawable.applyTheme(t);
            assertEquals(origWidth, scaledDrawable.getIntrinsicWidth());
            assertEquals(origHeight, scaledDrawable.getIntrinsicHeight());
            assertTrue(scaledDrawable.getPadding(tempPadding));
            assertEquals(origPadding, tempPadding);
        }
    }

    private static NinePatchDrawable preloadedDrawable(Resources res, int densityDpi, int sourceResId)
            throws XmlPullParserException, IOException {
        DrawableTestUtils.setResourcesDensity(res, densityDpi);
        final XmlResourceParser parser = DrawableTestUtils.getResourceParser(res, sourceResId);
        final NinePatchDrawable preloadedDrawable = new NinePatchDrawable(null);
        preloadedDrawable.inflate(res, parser, Xml.asAttributeSet(parser));
        return preloadedDrawable;
    }

    @Test
    public void testOutlinePreloadDensity() throws XmlPullParserException, IOException {
        final Resources res = mResources;
        final int densityDpi = res.getConfiguration().densityDpi;
        try {
            verifyOutlinePreloadDensityInner(res);
        } finally {
            DrawableTestUtils.setResourcesDensity(res, densityDpi);
        }
    }

    private static void verifyOutlinePreloadDensityInner(Resources res)
            throws XmlPullParserException, IOException {
        // Capture initial state at preload density.
        final int preloadDensityDpi = DENSITY_VALUES[0];
        final NinePatchDrawable preloadedDrawable = preloadedDrawable(res, preloadDensityDpi,
                R.drawable.nine_patch_odd_insets);

        final ConstantState preloadedConstantState = preloadedDrawable.getConstantState();
        final int bound = 40;
        final int expectedInset = 5;
        preloadedDrawable.setBounds(0, 0, bound, bound);
        final Outline origOutline = new Outline();
        preloadedDrawable.getOutline(origOutline);
        final Rect origOutlineRect = new Rect();
        origOutline.getRect(origOutlineRect);
        assertEquals(new Rect(expectedInset, expectedInset, bound - expectedInset,
                bound - expectedInset), origOutlineRect);
        final float origOutlineRadius = origOutline.getRadius();
        float expectedRadius = 6.8f;
        assertEquals(expectedRadius, origOutlineRadius, 0.1f);
        for (int i = 1; i < DENSITY_VALUES.length; i++) {
            final int scaledDensityDpi = DENSITY_VALUES[i];
            final float scale = scaledDensityDpi / (float) preloadDensityDpi;
            DrawableTestUtils.setResourcesDensity(res, scaledDensityDpi);
            final NinePatchDrawable scaledDrawable =
                    (NinePatchDrawable) preloadedConstantState.newDrawable(res);

            int scaledBound = (int) (bound * scale);
            scaledDrawable.setBounds(0, 0, scaledBound, scaledBound);

            final Outline tempOutline = new Outline();
            scaledDrawable.getOutline(tempOutline);
            final Rect tempOutlineRect = new Rect();
            assertTrue(tempOutline.getRect(tempOutlineRect));
            assertEquals((int) Math.ceil(origOutlineRect.left * scale), tempOutlineRect.left);
            assertEquals((int) Math.ceil(origOutlineRect.top * scale), tempOutlineRect.top);
            assertEquals((int) Math.floor(origOutlineRect.right * scale), tempOutlineRect.right);
            assertEquals((int) Math.floor(origOutlineRect.bottom * scale), tempOutlineRect.bottom);
            assertEquals(origOutlineRadius * scale, tempOutline.getRadius(), 0.1f);
        }
    }

    private void verifyColorFillRect(Bitmap bmp, int x, int y, int w, int h, int color) {
        for (int i = x; i < x + w; i++) {
            for (int j = y; j < y + h; j++) {
                assertEquals(color, bmp.getPixel(i, j));
            }
        }
    }

    private NinePatchDrawable getNinePatchDrawable(int resId) {
        // jump through hoops to avoid scaling the tiny ninepatch, which would skew the results
        // depending on device density
        Bitmap bitmap = getBitmapUnscaled(resId);
        NinePatch np = new NinePatch(bitmap, bitmap.getNinePatchChunk(), null);
        return new NinePatchDrawable(mResources, np);
    }

    private Bitmap getBitmapUnscaled(int resId) {
        BitmapFactory.Options opts = new BitmapFactory.Options();
        opts.inDensity = opts.inTargetDensity = mResources.getDisplayMetrics().densityDpi;
        Bitmap bitmap = BitmapFactory.decodeResource(mResources, resId, opts);
        return bitmap;
    }

    private void compareOrSave(Drawable dr, int densityDpi, int sourceResId, int goldenResId) {
        final int width = dr.getIntrinsicWidth();
        final int height = dr.getIntrinsicHeight();
        final Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
        bitmap.setDensity(0);

        final Canvas canvas = new Canvas(bitmap);
        dr.setBounds(0, 0, width, height);
        dr.draw(canvas);

        if (DBG_DUMP_PNG) {
            saveGoldenImage(bitmap, sourceResId, densityDpi);
        } else {
            final Bitmap golden = BitmapFactory.decodeResource(mResources, goldenResId);
            DrawableTestUtils.compareImages(densityDpi + " dpi", golden, bitmap,
                    PIXEL_ERROR_THRESHOLD, PIXEL_ERROR_COUNT_THRESHOLD, 0 /* tolerance */);
        }
    }

    private void saveGoldenImage(Bitmap bitmap, int sourceResId, int densityDpi) {
        // Save the image to the disk.
        FileOutputStream out = null;

        try {
            final String outputFolder = "/sdcard/temp/";
            final File folder = new File(outputFolder);
            if (!folder.exists()) {
                folder.mkdir();
            }

            final String sourceFilename = new File(mResources.getString(sourceResId)).getName();
            final String sourceTitle = sourceFilename.substring(0, sourceFilename.lastIndexOf("."));
            final String outputTitle = sourceTitle + "_golden_" + densityDpi;
            final String outputFilename = outputFolder + outputTitle + ".png";
            final File outputFile = new File(outputFilename);
            if (!outputFile.exists()) {
                outputFile.createNewFile();
            }

            out = new FileOutputStream(outputFile, false);
            bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}