/*
 * Copyright (C) 2013 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 com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics;

import java.util.ArrayList;
import java.util.List;

import junit.framework.TestCase;

import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;

import com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics.NinePatchedImage.Chunk;
import com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics.NinePatchedImage.Projection;
import com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics.NinePatchedImage.Tick;

public class NinePatchedImageTest extends TestCase {

    private static final String DIR = "/com/android/ide/eclipse/testdata/draw9patch/";

    public void testReadNoPatchedImage() throws Exception {
        String fileName = DIR + "no-patched.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        ImageData data = image.getImageData();
        int width = data.width;
        int height = data.height;

        assertEquals(72, width);
        assertEquals(50, height);

        assertFalse(image.hasNinePatchExtension());
    }

    public void testReadNoPatchedInteraceImage() throws Exception {
        String fileName = DIR + "no-patched-interlace.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        ImageData data = image.getImageData();
        int width = data.width;
        int height = data.height;

        assertEquals(72, width);
        assertEquals(50, height);

        assertFalse(image.hasNinePatchExtension());
    }

    public void testConvert9PatchedImage() throws Exception {
        String fileName = DIR + "no-patched.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        ImageData data = image.getImageData();
        int width = data.width;
        int height = data.height;

        assertEquals(72, width);
        assertEquals(50, height);

        assertFalse(image.hasNinePatchExtension());

        image.convertToNinePatch();

        data = image.getImageData();
        width = data.width;
        height = data.height;

        // increased patch size
        assertEquals(72 + 2, width);
        assertEquals(50 + 2, height);

        assertTrue(image.hasNinePatchExtension());
        assertFalse(image.isDirty());

        // initialized patches
        List<Tick> horizontalPatches = image.getHorizontalPatches();
        List<Tick> verticalPatches = image.getVerticalPatches();
        assertEquals(1, horizontalPatches.size());
        assertEquals(1, verticalPatches.size());

        // initialized contents area
        List<Tick> horizontalContentsArea = image.getHorizontalContents();
        List<Tick> verticalContentsArea = image.getVerticalContents();
        assertEquals(1, horizontalContentsArea.size());
        assertEquals(1, verticalContentsArea.size());

        // content area rectangle
        Rectangle contentsArea = image.getContentArea();
        assertEquals(new Rectangle(1, 1, width - 2, height - 2), contentsArea);
    }

    public void testReadInvalidPatchedImageCorners() throws Exception {

        // top-left
        String fileName = DIR + "invalid-patched1.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);
        assertTrue(image.hasNinePatchExtension());
        assertFalse(image.ensure9Patch());

        // top-right
        fileName = DIR + "invalid-patched2.9.png";
        image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);
        assertTrue(image.hasNinePatchExtension());
        assertFalse(image.ensure9Patch());

        // bottom-left
        fileName = DIR + "invalid-patched3.9.png";
        image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);
        assertTrue(image.hasNinePatchExtension());
        assertFalse(image.ensure9Patch());

        // bottom-right
        fileName = DIR + "invalid-patched4.9.png";
        image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);
        assertTrue(image.hasNinePatchExtension());
        assertFalse(image.ensure9Patch());
    }

    public void testReadInvalidPatchedImageLine() throws Exception {

        // top
        String fileName = DIR + "invalid-patched5.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);
        assertTrue(image.hasNinePatchExtension());
        assertFalse(image.ensure9Patch());

        // right
        fileName = DIR + "invalid-patched6.9.png";
        image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);
        assertTrue(image.hasNinePatchExtension());
        assertFalse(image.ensure9Patch());

        // bottom
        fileName = DIR + "invalid-patched7.9.png";
        image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);
        assertTrue(image.hasNinePatchExtension());
        assertFalse(image.ensure9Patch());

        // left
        fileName = DIR + "invalid-patched8.9.png";
        image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);
        assertTrue(image.hasNinePatchExtension());
        assertFalse(image.ensure9Patch());
    }

    public void testEnsure9PatchIgnoreInvalidPixels() throws Exception {
        // top
        String fileName = DIR + "invalid-patched5.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        // invalid pixel
        int invalidPixel = image.getImageData().getPixel(33, 0);
        assertTrue(0x0 != invalidPixel);

        assertTrue(image.hasNinePatchExtension());
        assertFalse(image.ensure9Patch());

        // ensure9path() ignored invalid pixels
        int invalidPixelAlpha = image.getImageData().getAlpha(33, 0);
        assertEquals(0x00, invalidPixelAlpha);
    }

    public void test9Patch1() throws Exception {
        String fileName = DIR + "patched1.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        assertTrue(image.hasNinePatchExtension());
        assertTrue(image.ensure9Patch());

        // patches
        List<Tick> horizontalPatches = image.getHorizontalPatches();
        List<Tick> verticalPatches = image.getVerticalPatches();
        assertEquals(3, horizontalPatches.size());
        assertEquals(3, verticalPatches.size());

        Chunk[][] chunks = null;
        chunks = image.getChunks(chunks);

        // vertical chunk size
        assertEquals(3, chunks.length);

        // horizontal chunk size
        for (int i = 0; i < chunks.length; i++) {
            assertEquals(3, chunks[i].length);
        }

        Chunk c = null;
        Rectangle rect = null;

        // Row 1
        c = chunks[0][0];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(1, rect.x);
        assertEquals(1, rect.y);
        assertEquals(1, rect.width);
        assertEquals(1, rect.height);

        c = chunks[0][1];
        rect = c.rect;
        assertEquals(Chunk.TYPE_VERTICAL, c.type);
        assertEquals(2, rect.x);
        assertEquals(1, rect.y);
        assertEquals(70, rect.width);
        assertEquals(1, rect.height);

        c = chunks[0][2];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(72, rect.x);
        assertEquals(1, rect.y);
        assertEquals(1, rect.width);
        assertEquals(1, rect.height);

        // Row 2
        c = chunks[1][0];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(1, rect.x);
        assertEquals(2, rect.y);
        assertEquals(1, rect.width);
        assertEquals(48, rect.height);

        c = chunks[1][1];
        rect = c.rect;
        assertEquals(Chunk.TYPE_FIXED, c.type);
        assertEquals(2, rect.x);
        assertEquals(2, rect.y);
        assertEquals(70, rect.width);
        assertEquals(48, rect.height);

        c = chunks[1][2];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(72, rect.x);
        assertEquals(2, rect.y);
        assertEquals(1, rect.width);
        assertEquals(48, rect.height);

        // Row 3
        c = chunks[2][0];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(1, rect.x);
        assertEquals(50, rect.y);
        assertEquals(1, rect.width);
        assertEquals(1, rect.height);

        c = chunks[2][1];
        rect = c.rect;
        assertEquals(Chunk.TYPE_VERTICAL, c.type);
        assertEquals(2, rect.x);
        assertEquals(50, rect.y);
        assertEquals(70, rect.width);
        assertEquals(1, rect.height);

        c = chunks[2][2];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(72, rect.x);
        assertEquals(50, rect.y);
        assertEquals(1, rect.width);
        assertEquals(1, rect.height);
    }

    public void test9Patch2() throws Exception {
        String fileName = DIR + "patched2.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        assertTrue(image.hasNinePatchExtension());
        assertTrue(image.ensure9Patch());

        // patches
        List<Tick> horizontalPatches = image.getHorizontalPatches();
        List<Tick> verticalPatches = image.getVerticalPatches();
        assertEquals(5, horizontalPatches.size());
        assertEquals(7, verticalPatches.size());

        NinePatchedImage.Chunk[][] chunks = null;
        chunks = image.getChunks(chunks);

        // vertical chunk size
        assertEquals(7, chunks.length);

        // horizontal chunk size
        for (int i = 0; i < chunks.length; i++) {
            assertEquals(5, chunks[i].length);
        }

        NinePatchedImage.Chunk c = null;
        Rectangle rect = null;

        // Row 1
        c = chunks[0][0];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(1, rect.x);
        assertEquals(1, rect.y);
        assertEquals(1, rect.width);
        assertEquals(1, rect.height);

        c = chunks[0][1];
        rect = c.rect;
        assertEquals(Chunk.TYPE_VERTICAL, c.type);
        assertEquals(2, rect.x);
        assertEquals(1, rect.y);
        assertEquals(34, rect.width);
        assertEquals(1, rect.height);

        c = chunks[0][2];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(36, rect.x);
        assertEquals(1, rect.y);
        assertEquals(1, rect.width);
        assertEquals(1, rect.height);

        c = chunks[0][3];
        rect = c.rect;
        assertEquals(Chunk.TYPE_VERTICAL, c.type);
        assertEquals(37, rect.x);
        assertEquals(1, rect.y);
        assertEquals(35, rect.width);
        assertEquals(1, rect.height);

        c = chunks[0][4];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(72, rect.x);
        assertEquals(1, rect.y);
        assertEquals(1, rect.width);
        assertEquals(1, rect.height);

        // Row 2
        c = chunks[1][0];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(1, rect.x);
        assertEquals(2, rect.y);
        assertEquals(1, rect.width);
        assertEquals(7, rect.height);

        c = chunks[1][1];
        rect = c.rect;
        assertEquals(Chunk.TYPE_FIXED, c.type);
        assertEquals(2, rect.x);
        assertEquals(2, rect.y);
        assertEquals(34, rect.width);
        assertEquals(7, rect.height);

        c = chunks[1][2];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(36, rect.x);
        assertEquals(2, rect.y);
        assertEquals(1, rect.width);
        assertEquals(7, rect.height);

        c = chunks[1][3];
        rect = c.rect;
        assertEquals(Chunk.TYPE_FIXED, c.type);
        assertEquals(37, rect.x);
        assertEquals(2, rect.y);
        assertEquals(35, rect.width);
        assertEquals(7, rect.height);

        c = chunks[1][4];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(72, rect.x);
        assertEquals(2, rect.y);
        assertEquals(1, rect.width);
        assertEquals(7, rect.height);

        // Row 3
        c = chunks[2][0];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(1, rect.x);
        assertEquals(9, rect.y);
        assertEquals(1, rect.width);
        assertEquals(4, rect.height);

        c = chunks[2][1];
        rect = c.rect;
        assertEquals(Chunk.TYPE_VERTICAL, c.type);
        assertEquals(2, rect.x);
        assertEquals(9, rect.y);
        assertEquals(34, rect.width);
        assertEquals(4, rect.height);

        c = chunks[2][2];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(36, rect.x);
        assertEquals(9, rect.y);
        assertEquals(1, rect.width);
        assertEquals(4, rect.height);

        c = chunks[2][3];
        rect = c.rect;
        assertEquals(Chunk.TYPE_VERTICAL, c.type);
        assertEquals(37, rect.x);
        assertEquals(9, rect.y);
        assertEquals(35, rect.width);
        assertEquals(4, rect.height);

        c = chunks[2][4];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(72, rect.x);
        assertEquals(9, rect.y);
        assertEquals(1, rect.width);
        assertEquals(4, rect.height);

        // Row 4
        c = chunks[3][0];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(1, rect.x);
        assertEquals(13, rect.y);
        assertEquals(1, rect.width);
        assertEquals(13, rect.height);

        c = chunks[3][1];
        rect = c.rect;
        assertEquals(Chunk.TYPE_FIXED, c.type);
        assertEquals(2, rect.x);
        assertEquals(13, rect.y);
        assertEquals(34, rect.width);
        assertEquals(13, rect.height);

        c = chunks[3][2];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(36, rect.x);
        assertEquals(13, rect.y);
        assertEquals(1, rect.width);
        assertEquals(13, rect.height);

        c = chunks[3][3];
        rect = c.rect;
        assertEquals(Chunk.TYPE_FIXED, c.type);
        assertEquals(37, rect.x);
        assertEquals(13, rect.y);
        assertEquals(35, rect.width);
        assertEquals(13, rect.height);

        c = chunks[3][4];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(72, rect.x);
        assertEquals(13, rect.y);
        assertEquals(1, rect.width);
        assertEquals(13, rect.height);

        // Row 5
        c = chunks[4][0];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(1, rect.x);
        assertEquals(26, rect.y);
        assertEquals(1, rect.width);
        assertEquals(12, rect.height);

        c = chunks[4][1];
        rect = c.rect;
        assertEquals(Chunk.TYPE_VERTICAL, c.type);
        assertEquals(2, rect.x);
        assertEquals(26, rect.y);
        assertEquals(34, rect.width);
        assertEquals(12, rect.height);

        c = chunks[4][2];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(36, rect.x);
        assertEquals(26, rect.y);
        assertEquals(1, rect.width);
        assertEquals(12, rect.height);

        c = chunks[4][3];
        rect = c.rect;
        assertEquals(Chunk.TYPE_VERTICAL, c.type);
        assertEquals(37, rect.x);
        assertEquals(26, rect.y);
        assertEquals(35, rect.width);
        assertEquals(12, rect.height);

        c = chunks[4][4];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(72, rect.x);
        assertEquals(26, rect.y);
        assertEquals(1, rect.width);
        assertEquals(12, rect.height);

        // Row 6
        c = chunks[5][0];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(1, rect.x);
        assertEquals(38, rect.y);
        assertEquals(1, rect.width);
        assertEquals(12, rect.height);

        c = chunks[5][1];
        rect = c.rect;
        assertEquals(Chunk.TYPE_FIXED, c.type);
        assertEquals(2, rect.x);
        assertEquals(38, rect.y);
        assertEquals(34, rect.width);
        assertEquals(12, rect.height);

        c = chunks[5][2];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(36, rect.x);
        assertEquals(38, rect.y);
        assertEquals(1, rect.width);
        assertEquals(12, rect.height);

        c = chunks[5][3];
        rect = c.rect;
        assertEquals(Chunk.TYPE_FIXED, c.type);
        assertEquals(37, rect.x);
        assertEquals(38, rect.y);
        assertEquals(35, rect.width);
        assertEquals(12, rect.height);

        c = chunks[5][4];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
        assertEquals(72, rect.x);
        assertEquals(38, rect.y);
        assertEquals(1, rect.width);
        assertEquals(12, rect.height);

        // Row 7
        c = chunks[6][0];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(1, rect.x);
        assertEquals(50, rect.y);
        assertEquals(1, rect.width);
        assertEquals(1, rect.height);

        c = chunks[6][1];
        rect = c.rect;
        assertEquals(Chunk.TYPE_VERTICAL, c.type);
        assertEquals(2, rect.x);
        assertEquals(50, rect.y);
        assertEquals(34, rect.width);
        assertEquals(1, rect.height);

        c = chunks[6][2];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(36, rect.x);
        assertEquals(50, rect.y);
        assertEquals(1, rect.width);
        assertEquals(1, rect.height);

        c = chunks[6][3];
        rect = c.rect;
        assertEquals(Chunk.TYPE_VERTICAL, c.type);
        assertEquals(37, rect.x);
        assertEquals(50, rect.y);
        assertEquals(35, rect.width);
        assertEquals(1, rect.height);

        c = chunks[6][4];
        rect = c.rect;
        assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
        assertEquals(72, rect.x);
        assertEquals(50, rect.y);
        assertEquals(1, rect.width);
        assertEquals(1, rect.height);
    }

    public void testContentArea() throws Exception {
        String fileName = DIR + "content-area.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        assertTrue(image.hasNinePatchExtension());
        assertTrue(image.ensure9Patch());

        // contents area
        List<Tick> horizontalContentsArea = image.getHorizontalContents();
        List<Tick> verticalContentsArea = image.getVerticalContents();
        assertEquals(3, horizontalContentsArea.size());
        assertEquals(3, verticalContentsArea.size());

        // content area rectangle
        Rectangle contentsArea = image.getContentArea();
        assertEquals(new Rectangle(19, 13, 35, 25), contentsArea);
    }

    public void testContentAreaOneDot() throws Exception {
        String fileName = DIR + "content-area-one-dot.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        assertTrue(image.hasNinePatchExtension());
        assertTrue(image.ensure9Patch());

        // contents area
        List<Tick> horizontalContentsArea = image.getHorizontalContents();
        List<Tick> verticalContentsArea = image.getVerticalContents();
        assertEquals(3, horizontalContentsArea.size());
        assertEquals(3, verticalContentsArea.size());

        // content area rectangle
        Rectangle contentsArea = image.getContentArea();
        assertEquals(new Rectangle(19, 13, 1, 1), contentsArea);
    }

    public void testContentAreaTwoDots() throws Exception {
        String fileName = DIR + "content-area-two-dots.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        assertTrue(image.hasNinePatchExtension());
        assertTrue(image.ensure9Patch());

        // contents area
        List<Tick> horizontalContentsArea = image.getHorizontalContents();
        List<Tick> verticalContentsArea = image.getVerticalContents();
        assertEquals(5, horizontalContentsArea.size());
        assertEquals(5, verticalContentsArea.size());

        // content area rectangle
        Rectangle contentsArea = image.getContentArea();
        assertEquals(new Rectangle(19, 13, 35, 25), contentsArea);

        String fileName2 = DIR + "content-area.9.png";
        NinePatchedImage image2 = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName2), fileName2);
        assertNotNull(image2);

        assertTrue(image2.hasNinePatchExtension());
        assertTrue(image2.ensure9Patch());

        // content area rectangle
        Rectangle contentsArea2 = image2.getContentArea();
        assertEquals(contentsArea2, contentsArea);
    }

    public void testBadPatches() throws Exception {
        String fileName = DIR + "patched-with-badpatches.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        assertTrue(image.hasNinePatchExtension());
        assertTrue(image.ensure9Patch());

        Chunk[][] chunks = null;
        chunks = image.getChunks(chunks);

        // vertical chunk size
        assertEquals(5, chunks.length);

        // horizontal chunk size
        for (int i = 0; i < chunks.length; i++) {
            assertEquals(7, chunks[i].length);
        }

        chunks = image.getCorruptedChunks(chunks);

        Chunk c = null;

        // collect bad patches
        List<Point> badPatches = new ArrayList<Point>(5 * 7);
        for (int y = 0; y < chunks.length; y++) {
            for (int x = 0; x < chunks[0].length; x++) {
                c = chunks[y][x];
                if ((c.type & Chunk.TYPE_CORRUPT) != 0x0) {
                    badPatches.add(new Point(y, x));
                }
            }
        }

        assertEquals(15, badPatches.size());

        assertTrue(badPatches.contains(new Point(0, 3)));

        assertTrue(badPatches.contains(new Point(1, 1)));
        assertTrue(badPatches.contains(new Point(1, 2)));
        assertTrue(badPatches.contains(new Point(1, 3)));
        assertTrue(badPatches.contains(new Point(1, 4)));
        assertTrue(badPatches.contains(new Point(1, 5)));

        assertTrue(badPatches.contains(new Point(2, 1)));
        assertTrue(badPatches.contains(new Point(2, 5)));

        assertTrue(badPatches.contains(new Point(3, 0)));
        assertTrue(badPatches.contains(new Point(3, 1)));
        assertTrue(badPatches.contains(new Point(3, 5)));
        assertTrue(badPatches.contains(new Point(3, 6)));

        assertTrue(badPatches.contains(new Point(4, 1)));
        assertTrue(badPatches.contains(new Point(4, 3)));
        assertTrue(badPatches.contains(new Point(4, 5)));
    }

    public void testProjection() throws Exception {
        // top
        String fileName = DIR + "patched3.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        assertTrue(image.hasNinePatchExtension());
        assertTrue(image.ensure9Patch());

        ImageData data = image.getImageData();
        assertEquals(72 + 2, data.width);
        assertEquals(50 + 2, data.height);

        int width = 72 * 2;
        int height = 50 * 2;

        Chunk[][] chunks = null;
        chunks = image.getChunks(chunks);

        Projection[][] projections = null;
        projections = image.getProjections(width, height, projections);

        assertEquals(chunks.length, projections.length);
        for (int i = 0; i < chunks.length; i++) {
            assertEquals(chunks[i].length, projections[i].length);
        }

        for (int y = 0; y < projections.length; y++) {
            for (int x = 0; x < projections[y].length; x++) {
                assertEquals(projections[y][x].src, chunks[y][x].rect);

                // If chunk type is FIXED. Same projection size as original
                // chunk.
                if (projections[y][x].chunk.type == Chunk.TYPE_FIXED) {
                    assertEquals(projections[y][x].dest.width, chunks[y][x].rect.width);
                    assertEquals(projections[y][x].dest.height, chunks[y][x].rect.height);
                }
            }
        }

        Projection p = null;
        Rectangle rect = null;

        // Check start position
        p = projections[0][0];

        // src position start from 1, 9-patch row and column included.
        assertEquals(1, p.src.x);
        assertEquals(1, p.src.y);

        // dest position start from 0, 9-patch row and column ignored.
        assertEquals(0, p.dest.x);
        assertEquals(0, p.dest.y);

        // row 1
        p = projections[0][0];
        rect = p.dest;
        assertEquals(0, rect.x);
        assertEquals(0, rect.y);
        assertEquals(74, rect.width);
        assertEquals(5, rect.height);

        p = projections[0][1];
        rect = p.dest;
        assertEquals(74, rect.x);
        assertEquals(0, rect.y);
        assertEquals(62, rect.width);
        assertEquals(5, rect.height);

        p = projections[0][2];
        rect = p.dest;
        assertEquals(136, rect.x);
        assertEquals(0, rect.y);
        assertEquals(8, rect.width);
        assertEquals(5, rect.height);

        // row 2
        p = projections[1][0];
        rect = p.dest;
        assertEquals(0, rect.x);
        assertEquals(5, rect.y);
        assertEquals(74, rect.width);
        assertEquals(24, rect.height);

        p = projections[1][1];
        rect = p.dest;
        assertEquals(74, rect.x);
        assertEquals(5, rect.y);
        assertEquals(62, rect.width);
        assertEquals(24, rect.height);

        p = projections[1][2];
        rect = p.dest;
        assertEquals(136, rect.x);
        assertEquals(5, rect.y);
        assertEquals(8, rect.width);
        assertEquals(24, rect.height);

        // row 3
        p = projections[2][0];
        rect = p.dest;
        assertEquals(0, rect.x);
        assertEquals(29, rect.y);
        assertEquals(74, rect.width);
        assertEquals(58, rect.height);

        p = projections[2][1];
        rect = p.dest;
        assertEquals(74, rect.x);
        assertEquals(29, rect.y);
        assertEquals(62, rect.width);
        assertEquals(58, rect.height);

        p = projections[2][2];
        rect = p.dest;
        assertEquals(136, rect.x);
        assertEquals(29, rect.y);
        assertEquals(8, rect.width);
        assertEquals(58, rect.height);

        // row 4
        p = projections[3][0];
        rect = p.dest;
        assertEquals(0, rect.x);
        assertEquals(87, rect.y);
        assertEquals(74, rect.width);
        assertEquals(13, rect.height);

        p = projections[3][1];
        rect = p.dest;
        assertEquals(74, rect.x);
        assertEquals(87, rect.y);
        assertEquals(62, rect.width);
        assertEquals(13, rect.height);

        p = projections[3][2];
        rect = p.dest;
        assertEquals(136, rect.x);
        assertEquals(87, rect.y);
        assertEquals(8, rect.width);
        assertEquals(13, rect.height);
    }

    public void testReadLayoutBoundsOnlyImage() throws Exception {
        String fileName = DIR + "layout-bounds-only.9.png";
        NinePatchedImage image = new NinePatchedImage(getClass()
                .getResourceAsStream(fileName), fileName);
        assertNotNull(image);

        ImageData data = image.getImageData();
        int width = data.width;
        int height = data.height;

        assertEquals(74, width);
        assertEquals(52, height);

        assertTrue(image.hasNinePatchExtension());
        assertTrue(image.ensure9Patch());
    }
}