Home | History | Annotate | Download | only in graphics 
      1 /*
      2  * Copyright (C) 2013 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics;
     18 
     19 import java.util.ArrayList;
     20 import java.util.List;
     21 
     22 import junit.framework.TestCase;
     23 
     24 import org.eclipse.swt.graphics.ImageData;
     25 import org.eclipse.swt.graphics.Point;
     26 import org.eclipse.swt.graphics.Rectangle;
     27 
     28 import com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics.NinePatchedImage.Chunk;
     29 import com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics.NinePatchedImage.Projection;
     30 import com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics.NinePatchedImage.Tick;
     31 
     32 public class NinePatchedImageTest extends TestCase {
     33 
     34     private static final String DIR = "/com/android/ide/eclipse/testdata/draw9patch/";
     35 
     36     public void testReadNoPatchedImage() throws Exception {
     37         String fileName = DIR + "no-patched.png";
     38         NinePatchedImage image = new NinePatchedImage(getClass()
     39                 .getResourceAsStream(fileName), fileName);
     40         assertNotNull(image);
     41 
     42         ImageData data = image.getImageData();
     43         int width = data.width;
     44         int height = data.height;
     45 
     46         assertEquals(72, width);
     47         assertEquals(50, height);
     48 
     49         assertFalse(image.hasNinePatchExtension());
     50     }
     51 
     52     public void testReadNoPatchedInteraceImage() throws Exception {
     53         String fileName = DIR + "no-patched-interlace.png";
     54         NinePatchedImage image = new NinePatchedImage(getClass()
     55                 .getResourceAsStream(fileName), fileName);
     56         assertNotNull(image);
     57 
     58         ImageData data = image.getImageData();
     59         int width = data.width;
     60         int height = data.height;
     61 
     62         assertEquals(72, width);
     63         assertEquals(50, height);
     64 
     65         assertFalse(image.hasNinePatchExtension());
     66     }
     67 
     68     public void testConvert9PatchedImage() throws Exception {
     69         String fileName = DIR + "no-patched.png";
     70         NinePatchedImage image = new NinePatchedImage(getClass()
     71                 .getResourceAsStream(fileName), fileName);
     72         assertNotNull(image);
     73 
     74         ImageData data = image.getImageData();
     75         int width = data.width;
     76         int height = data.height;
     77 
     78         assertEquals(72, width);
     79         assertEquals(50, height);
     80 
     81         assertFalse(image.hasNinePatchExtension());
     82 
     83         image.convertToNinePatch();
     84 
     85         data = image.getImageData();
     86         width = data.width;
     87         height = data.height;
     88 
     89         // increased patch size
     90         assertEquals(72 + 2, width);
     91         assertEquals(50 + 2, height);
     92 
     93         assertTrue(image.hasNinePatchExtension());
     94         assertFalse(image.isDirty());
     95 
     96         // initialized patches
     97         List<Tick> horizontalPatches = image.getHorizontalPatches();
     98         List<Tick> verticalPatches = image.getVerticalPatches();
     99         assertEquals(1, horizontalPatches.size());
    100         assertEquals(1, verticalPatches.size());
    101 
    102         // initialized contents area
    103         List<Tick> horizontalContentsArea = image.getHorizontalContents();
    104         List<Tick> verticalContentsArea = image.getVerticalContents();
    105         assertEquals(1, horizontalContentsArea.size());
    106         assertEquals(1, verticalContentsArea.size());
    107 
    108         // content area rectangle
    109         Rectangle contentsArea = image.getContentArea();
    110         assertEquals(new Rectangle(1, 1, width - 2, height - 2), contentsArea);
    111     }
    112 
    113     public void testReadInvalidPatchedImageCorners() throws Exception {
    114 
    115         // top-left
    116         String fileName = DIR + "invalid-patched1.9.png";
    117         NinePatchedImage image = new NinePatchedImage(getClass()
    118                 .getResourceAsStream(fileName), fileName);
    119         assertNotNull(image);
    120         assertTrue(image.hasNinePatchExtension());
    121         assertFalse(image.ensure9Patch());
    122 
    123         // top-right
    124         fileName = DIR + "invalid-patched2.9.png";
    125         image = new NinePatchedImage(getClass()
    126                 .getResourceAsStream(fileName), fileName);
    127         assertNotNull(image);
    128         assertTrue(image.hasNinePatchExtension());
    129         assertFalse(image.ensure9Patch());
    130 
    131         // bottom-left
    132         fileName = DIR + "invalid-patched3.9.png";
    133         image = new NinePatchedImage(getClass()
    134                 .getResourceAsStream(fileName), fileName);
    135         assertNotNull(image);
    136         assertTrue(image.hasNinePatchExtension());
    137         assertFalse(image.ensure9Patch());
    138 
    139         // bottom-right
    140         fileName = DIR + "invalid-patched4.9.png";
    141         image = new NinePatchedImage(getClass()
    142                 .getResourceAsStream(fileName), fileName);
    143         assertNotNull(image);
    144         assertTrue(image.hasNinePatchExtension());
    145         assertFalse(image.ensure9Patch());
    146     }
    147 
    148     public void testReadInvalidPatchedImageLine() throws Exception {
    149 
    150         // top
    151         String fileName = DIR + "invalid-patched5.9.png";
    152         NinePatchedImage image = new NinePatchedImage(getClass()
    153                 .getResourceAsStream(fileName), fileName);
    154         assertNotNull(image);
    155         assertTrue(image.hasNinePatchExtension());
    156         assertFalse(image.ensure9Patch());
    157 
    158         // right
    159         fileName = DIR + "invalid-patched6.9.png";
    160         image = new NinePatchedImage(getClass()
    161                 .getResourceAsStream(fileName), fileName);
    162         assertNotNull(image);
    163         assertTrue(image.hasNinePatchExtension());
    164         assertFalse(image.ensure9Patch());
    165 
    166         // bottom
    167         fileName = DIR + "invalid-patched7.9.png";
    168         image = new NinePatchedImage(getClass()
    169                 .getResourceAsStream(fileName), fileName);
    170         assertNotNull(image);
    171         assertTrue(image.hasNinePatchExtension());
    172         assertFalse(image.ensure9Patch());
    173 
    174         // left
    175         fileName = DIR + "invalid-patched8.9.png";
    176         image = new NinePatchedImage(getClass()
    177                 .getResourceAsStream(fileName), fileName);
    178         assertNotNull(image);
    179         assertTrue(image.hasNinePatchExtension());
    180         assertFalse(image.ensure9Patch());
    181     }
    182 
    183     public void testEnsure9PatchIgnoreInvalidPixels() throws Exception {
    184         // top
    185         String fileName = DIR + "invalid-patched5.9.png";
    186         NinePatchedImage image = new NinePatchedImage(getClass()
    187                 .getResourceAsStream(fileName), fileName);
    188         assertNotNull(image);
    189 
    190         // invalid pixel
    191         int invalidPixel = image.getImageData().getPixel(33, 0);
    192         assertTrue(0x0 != invalidPixel);
    193 
    194         assertTrue(image.hasNinePatchExtension());
    195         assertFalse(image.ensure9Patch());
    196 
    197         // ensure9path() ignored invalid pixels
    198         int invalidPixelAlpha = image.getImageData().getAlpha(33, 0);
    199         assertEquals(0x00, invalidPixelAlpha);
    200     }
    201 
    202     public void test9Patch1() throws Exception {
    203         String fileName = DIR + "patched1.9.png";
    204         NinePatchedImage image = new NinePatchedImage(getClass()
    205                 .getResourceAsStream(fileName), fileName);
    206         assertNotNull(image);
    207 
    208         assertTrue(image.hasNinePatchExtension());
    209         assertTrue(image.ensure9Patch());
    210 
    211         // patches
    212         List<Tick> horizontalPatches = image.getHorizontalPatches();
    213         List<Tick> verticalPatches = image.getVerticalPatches();
    214         assertEquals(3, horizontalPatches.size());
    215         assertEquals(3, verticalPatches.size());
    216 
    217         Chunk[][] chunks = null;
    218         chunks = image.getChunks(chunks);
    219 
    220         // vertical chunk size
    221         assertEquals(3, chunks.length);
    222 
    223         // horizontal chunk size
    224         for (int i = 0; i < chunks.length; i++) {
    225             assertEquals(3, chunks[i].length);
    226         }
    227 
    228         Chunk c = null;
    229         Rectangle rect = null;
    230 
    231         // Row 1
    232         c = chunks[0][0];
    233         rect = c.rect;
    234         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    235         assertEquals(1, rect.x);
    236         assertEquals(1, rect.y);
    237         assertEquals(1, rect.width);
    238         assertEquals(1, rect.height);
    239 
    240         c = chunks[0][1];
    241         rect = c.rect;
    242         assertEquals(Chunk.TYPE_VERTICAL, c.type);
    243         assertEquals(2, rect.x);
    244         assertEquals(1, rect.y);
    245         assertEquals(70, rect.width);
    246         assertEquals(1, rect.height);
    247 
    248         c = chunks[0][2];
    249         rect = c.rect;
    250         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    251         assertEquals(72, rect.x);
    252         assertEquals(1, rect.y);
    253         assertEquals(1, rect.width);
    254         assertEquals(1, rect.height);
    255 
    256         // Row 2
    257         c = chunks[1][0];
    258         rect = c.rect;
    259         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    260         assertEquals(1, rect.x);
    261         assertEquals(2, rect.y);
    262         assertEquals(1, rect.width);
    263         assertEquals(48, rect.height);
    264 
    265         c = chunks[1][1];
    266         rect = c.rect;
    267         assertEquals(Chunk.TYPE_FIXED, c.type);
    268         assertEquals(2, rect.x);
    269         assertEquals(2, rect.y);
    270         assertEquals(70, rect.width);
    271         assertEquals(48, rect.height);
    272 
    273         c = chunks[1][2];
    274         rect = c.rect;
    275         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    276         assertEquals(72, rect.x);
    277         assertEquals(2, rect.y);
    278         assertEquals(1, rect.width);
    279         assertEquals(48, rect.height);
    280 
    281         // Row 3
    282         c = chunks[2][0];
    283         rect = c.rect;
    284         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    285         assertEquals(1, rect.x);
    286         assertEquals(50, rect.y);
    287         assertEquals(1, rect.width);
    288         assertEquals(1, rect.height);
    289 
    290         c = chunks[2][1];
    291         rect = c.rect;
    292         assertEquals(Chunk.TYPE_VERTICAL, c.type);
    293         assertEquals(2, rect.x);
    294         assertEquals(50, rect.y);
    295         assertEquals(70, rect.width);
    296         assertEquals(1, rect.height);
    297 
    298         c = chunks[2][2];
    299         rect = c.rect;
    300         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    301         assertEquals(72, rect.x);
    302         assertEquals(50, rect.y);
    303         assertEquals(1, rect.width);
    304         assertEquals(1, rect.height);
    305     }
    306 
    307     public void test9Patch2() throws Exception {
    308         String fileName = DIR + "patched2.9.png";
    309         NinePatchedImage image = new NinePatchedImage(getClass()
    310                 .getResourceAsStream(fileName), fileName);
    311         assertNotNull(image);
    312 
    313         assertTrue(image.hasNinePatchExtension());
    314         assertTrue(image.ensure9Patch());
    315 
    316         // patches
    317         List<Tick> horizontalPatches = image.getHorizontalPatches();
    318         List<Tick> verticalPatches = image.getVerticalPatches();
    319         assertEquals(5, horizontalPatches.size());
    320         assertEquals(7, verticalPatches.size());
    321 
    322         NinePatchedImage.Chunk[][] chunks = null;
    323         chunks = image.getChunks(chunks);
    324 
    325         // vertical chunk size
    326         assertEquals(7, chunks.length);
    327 
    328         // horizontal chunk size
    329         for (int i = 0; i < chunks.length; i++) {
    330             assertEquals(5, chunks[i].length);
    331         }
    332 
    333         NinePatchedImage.Chunk c = null;
    334         Rectangle rect = null;
    335 
    336         // Row 1
    337         c = chunks[0][0];
    338         rect = c.rect;
    339         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    340         assertEquals(1, rect.x);
    341         assertEquals(1, rect.y);
    342         assertEquals(1, rect.width);
    343         assertEquals(1, rect.height);
    344 
    345         c = chunks[0][1];
    346         rect = c.rect;
    347         assertEquals(Chunk.TYPE_VERTICAL, c.type);
    348         assertEquals(2, rect.x);
    349         assertEquals(1, rect.y);
    350         assertEquals(34, rect.width);
    351         assertEquals(1, rect.height);
    352 
    353         c = chunks[0][2];
    354         rect = c.rect;
    355         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    356         assertEquals(36, rect.x);
    357         assertEquals(1, rect.y);
    358         assertEquals(1, rect.width);
    359         assertEquals(1, rect.height);
    360 
    361         c = chunks[0][3];
    362         rect = c.rect;
    363         assertEquals(Chunk.TYPE_VERTICAL, c.type);
    364         assertEquals(37, rect.x);
    365         assertEquals(1, rect.y);
    366         assertEquals(35, rect.width);
    367         assertEquals(1, rect.height);
    368 
    369         c = chunks[0][4];
    370         rect = c.rect;
    371         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    372         assertEquals(72, rect.x);
    373         assertEquals(1, rect.y);
    374         assertEquals(1, rect.width);
    375         assertEquals(1, rect.height);
    376 
    377         // Row 2
    378         c = chunks[1][0];
    379         rect = c.rect;
    380         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    381         assertEquals(1, rect.x);
    382         assertEquals(2, rect.y);
    383         assertEquals(1, rect.width);
    384         assertEquals(7, rect.height);
    385 
    386         c = chunks[1][1];
    387         rect = c.rect;
    388         assertEquals(Chunk.TYPE_FIXED, c.type);
    389         assertEquals(2, rect.x);
    390         assertEquals(2, rect.y);
    391         assertEquals(34, rect.width);
    392         assertEquals(7, rect.height);
    393 
    394         c = chunks[1][2];
    395         rect = c.rect;
    396         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    397         assertEquals(36, rect.x);
    398         assertEquals(2, rect.y);
    399         assertEquals(1, rect.width);
    400         assertEquals(7, rect.height);
    401 
    402         c = chunks[1][3];
    403         rect = c.rect;
    404         assertEquals(Chunk.TYPE_FIXED, c.type);
    405         assertEquals(37, rect.x);
    406         assertEquals(2, rect.y);
    407         assertEquals(35, rect.width);
    408         assertEquals(7, rect.height);
    409 
    410         c = chunks[1][4];
    411         rect = c.rect;
    412         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    413         assertEquals(72, rect.x);
    414         assertEquals(2, rect.y);
    415         assertEquals(1, rect.width);
    416         assertEquals(7, rect.height);
    417 
    418         // Row 3
    419         c = chunks[2][0];
    420         rect = c.rect;
    421         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    422         assertEquals(1, rect.x);
    423         assertEquals(9, rect.y);
    424         assertEquals(1, rect.width);
    425         assertEquals(4, rect.height);
    426 
    427         c = chunks[2][1];
    428         rect = c.rect;
    429         assertEquals(Chunk.TYPE_VERTICAL, c.type);
    430         assertEquals(2, rect.x);
    431         assertEquals(9, rect.y);
    432         assertEquals(34, rect.width);
    433         assertEquals(4, rect.height);
    434 
    435         c = chunks[2][2];
    436         rect = c.rect;
    437         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    438         assertEquals(36, rect.x);
    439         assertEquals(9, rect.y);
    440         assertEquals(1, rect.width);
    441         assertEquals(4, rect.height);
    442 
    443         c = chunks[2][3];
    444         rect = c.rect;
    445         assertEquals(Chunk.TYPE_VERTICAL, c.type);
    446         assertEquals(37, rect.x);
    447         assertEquals(9, rect.y);
    448         assertEquals(35, rect.width);
    449         assertEquals(4, rect.height);
    450 
    451         c = chunks[2][4];
    452         rect = c.rect;
    453         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    454         assertEquals(72, rect.x);
    455         assertEquals(9, rect.y);
    456         assertEquals(1, rect.width);
    457         assertEquals(4, rect.height);
    458 
    459         // Row 4
    460         c = chunks[3][0];
    461         rect = c.rect;
    462         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    463         assertEquals(1, rect.x);
    464         assertEquals(13, rect.y);
    465         assertEquals(1, rect.width);
    466         assertEquals(13, rect.height);
    467 
    468         c = chunks[3][1];
    469         rect = c.rect;
    470         assertEquals(Chunk.TYPE_FIXED, c.type);
    471         assertEquals(2, rect.x);
    472         assertEquals(13, rect.y);
    473         assertEquals(34, rect.width);
    474         assertEquals(13, rect.height);
    475 
    476         c = chunks[3][2];
    477         rect = c.rect;
    478         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    479         assertEquals(36, rect.x);
    480         assertEquals(13, rect.y);
    481         assertEquals(1, rect.width);
    482         assertEquals(13, rect.height);
    483 
    484         c = chunks[3][3];
    485         rect = c.rect;
    486         assertEquals(Chunk.TYPE_FIXED, c.type);
    487         assertEquals(37, rect.x);
    488         assertEquals(13, rect.y);
    489         assertEquals(35, rect.width);
    490         assertEquals(13, rect.height);
    491 
    492         c = chunks[3][4];
    493         rect = c.rect;
    494         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    495         assertEquals(72, rect.x);
    496         assertEquals(13, rect.y);
    497         assertEquals(1, rect.width);
    498         assertEquals(13, rect.height);
    499 
    500         // Row 5
    501         c = chunks[4][0];
    502         rect = c.rect;
    503         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    504         assertEquals(1, rect.x);
    505         assertEquals(26, rect.y);
    506         assertEquals(1, rect.width);
    507         assertEquals(12, rect.height);
    508 
    509         c = chunks[4][1];
    510         rect = c.rect;
    511         assertEquals(Chunk.TYPE_VERTICAL, c.type);
    512         assertEquals(2, rect.x);
    513         assertEquals(26, rect.y);
    514         assertEquals(34, rect.width);
    515         assertEquals(12, rect.height);
    516 
    517         c = chunks[4][2];
    518         rect = c.rect;
    519         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    520         assertEquals(36, rect.x);
    521         assertEquals(26, rect.y);
    522         assertEquals(1, rect.width);
    523         assertEquals(12, rect.height);
    524 
    525         c = chunks[4][3];
    526         rect = c.rect;
    527         assertEquals(Chunk.TYPE_VERTICAL, c.type);
    528         assertEquals(37, rect.x);
    529         assertEquals(26, rect.y);
    530         assertEquals(35, rect.width);
    531         assertEquals(12, rect.height);
    532 
    533         c = chunks[4][4];
    534         rect = c.rect;
    535         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    536         assertEquals(72, rect.x);
    537         assertEquals(26, rect.y);
    538         assertEquals(1, rect.width);
    539         assertEquals(12, rect.height);
    540 
    541         // Row 6
    542         c = chunks[5][0];
    543         rect = c.rect;
    544         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    545         assertEquals(1, rect.x);
    546         assertEquals(38, rect.y);
    547         assertEquals(1, rect.width);
    548         assertEquals(12, rect.height);
    549 
    550         c = chunks[5][1];
    551         rect = c.rect;
    552         assertEquals(Chunk.TYPE_FIXED, c.type);
    553         assertEquals(2, rect.x);
    554         assertEquals(38, rect.y);
    555         assertEquals(34, rect.width);
    556         assertEquals(12, rect.height);
    557 
    558         c = chunks[5][2];
    559         rect = c.rect;
    560         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    561         assertEquals(36, rect.x);
    562         assertEquals(38, rect.y);
    563         assertEquals(1, rect.width);
    564         assertEquals(12, rect.height);
    565 
    566         c = chunks[5][3];
    567         rect = c.rect;
    568         assertEquals(Chunk.TYPE_FIXED, c.type);
    569         assertEquals(37, rect.x);
    570         assertEquals(38, rect.y);
    571         assertEquals(35, rect.width);
    572         assertEquals(12, rect.height);
    573 
    574         c = chunks[5][4];
    575         rect = c.rect;
    576         assertEquals(Chunk.TYPE_HORIZONTAL, c.type);
    577         assertEquals(72, rect.x);
    578         assertEquals(38, rect.y);
    579         assertEquals(1, rect.width);
    580         assertEquals(12, rect.height);
    581 
    582         // Row 7
    583         c = chunks[6][0];
    584         rect = c.rect;
    585         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    586         assertEquals(1, rect.x);
    587         assertEquals(50, rect.y);
    588         assertEquals(1, rect.width);
    589         assertEquals(1, rect.height);
    590 
    591         c = chunks[6][1];
    592         rect = c.rect;
    593         assertEquals(Chunk.TYPE_VERTICAL, c.type);
    594         assertEquals(2, rect.x);
    595         assertEquals(50, rect.y);
    596         assertEquals(34, rect.width);
    597         assertEquals(1, rect.height);
    598 
    599         c = chunks[6][2];
    600         rect = c.rect;
    601         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    602         assertEquals(36, rect.x);
    603         assertEquals(50, rect.y);
    604         assertEquals(1, rect.width);
    605         assertEquals(1, rect.height);
    606 
    607         c = chunks[6][3];
    608         rect = c.rect;
    609         assertEquals(Chunk.TYPE_VERTICAL, c.type);
    610         assertEquals(37, rect.x);
    611         assertEquals(50, rect.y);
    612         assertEquals(35, rect.width);
    613         assertEquals(1, rect.height);
    614 
    615         c = chunks[6][4];
    616         rect = c.rect;
    617         assertEquals(Chunk.TYPE_HORIZONTAL | Chunk.TYPE_VERTICAL, c.type);
    618         assertEquals(72, rect.x);
    619         assertEquals(50, rect.y);
    620         assertEquals(1, rect.width);
    621         assertEquals(1, rect.height);
    622     }
    623 
    624     public void testContentArea() throws Exception {
    625         String fileName = DIR + "content-area.9.png";
    626         NinePatchedImage image = new NinePatchedImage(getClass()
    627                 .getResourceAsStream(fileName), fileName);
    628         assertNotNull(image);
    629 
    630         assertTrue(image.hasNinePatchExtension());
    631         assertTrue(image.ensure9Patch());
    632 
    633         // contents area
    634         List<Tick> horizontalContentsArea = image.getHorizontalContents();
    635         List<Tick> verticalContentsArea = image.getVerticalContents();
    636         assertEquals(3, horizontalContentsArea.size());
    637         assertEquals(3, verticalContentsArea.size());
    638 
    639         // content area rectangle
    640         Rectangle contentsArea = image.getContentArea();
    641         assertEquals(new Rectangle(19, 13, 35, 25), contentsArea);
    642     }
    643 
    644     public void testContentAreaOneDot() throws Exception {
    645         String fileName = DIR + "content-area-one-dot.9.png";
    646         NinePatchedImage image = new NinePatchedImage(getClass()
    647                 .getResourceAsStream(fileName), fileName);
    648         assertNotNull(image);
    649 
    650         assertTrue(image.hasNinePatchExtension());
    651         assertTrue(image.ensure9Patch());
    652 
    653         // contents area
    654         List<Tick> horizontalContentsArea = image.getHorizontalContents();
    655         List<Tick> verticalContentsArea = image.getVerticalContents();
    656         assertEquals(3, horizontalContentsArea.size());
    657         assertEquals(3, verticalContentsArea.size());
    658 
    659         // content area rectangle
    660         Rectangle contentsArea = image.getContentArea();
    661         assertEquals(new Rectangle(19, 13, 1, 1), contentsArea);
    662     }
    663 
    664     public void testContentAreaTwoDots() throws Exception {
    665         String fileName = DIR + "content-area-two-dots.9.png";
    666         NinePatchedImage image = new NinePatchedImage(getClass()
    667                 .getResourceAsStream(fileName), fileName);
    668         assertNotNull(image);
    669 
    670         assertTrue(image.hasNinePatchExtension());
    671         assertTrue(image.ensure9Patch());
    672 
    673         // contents area
    674         List<Tick> horizontalContentsArea = image.getHorizontalContents();
    675         List<Tick> verticalContentsArea = image.getVerticalContents();
    676         assertEquals(5, horizontalContentsArea.size());
    677         assertEquals(5, verticalContentsArea.size());
    678 
    679         // content area rectangle
    680         Rectangle contentsArea = image.getContentArea();
    681         assertEquals(new Rectangle(19, 13, 35, 25), contentsArea);
    682 
    683         String fileName2 = DIR + "content-area.9.png";
    684         NinePatchedImage image2 = new NinePatchedImage(getClass()
    685                 .getResourceAsStream(fileName2), fileName2);
    686         assertNotNull(image2);
    687 
    688         assertTrue(image2.hasNinePatchExtension());
    689         assertTrue(image2.ensure9Patch());
    690 
    691         // content area rectangle
    692         Rectangle contentsArea2 = image2.getContentArea();
    693         assertEquals(contentsArea2, contentsArea);
    694     }
    695 
    696     public void testBadPatches() throws Exception {
    697         String fileName = DIR + "patched-with-badpatches.9.png";
    698         NinePatchedImage image = new NinePatchedImage(getClass()
    699                 .getResourceAsStream(fileName), fileName);
    700         assertNotNull(image);
    701 
    702         assertTrue(image.hasNinePatchExtension());
    703         assertTrue(image.ensure9Patch());
    704 
    705         Chunk[][] chunks = null;
    706         chunks = image.getChunks(chunks);
    707 
    708         // vertical chunk size
    709         assertEquals(5, chunks.length);
    710 
    711         // horizontal chunk size
    712         for (int i = 0; i < chunks.length; i++) {
    713             assertEquals(7, chunks[i].length);
    714         }
    715 
    716         chunks = image.getCorruptedChunks(chunks);
    717 
    718         Chunk c = null;
    719 
    720         // collect bad patches
    721         List<Point> badPatches = new ArrayList<Point>(5 * 7);
    722         for (int y = 0; y < chunks.length; y++) {
    723             for (int x = 0; x < chunks[0].length; x++) {
    724                 c = chunks[y][x];
    725                 if ((c.type & Chunk.TYPE_CORRUPT) != 0x0) {
    726                     badPatches.add(new Point(y, x));
    727                 }
    728             }
    729         }
    730 
    731         assertEquals(15, badPatches.size());
    732 
    733         assertTrue(badPatches.contains(new Point(0, 3)));
    734 
    735         assertTrue(badPatches.contains(new Point(1, 1)));
    736         assertTrue(badPatches.contains(new Point(1, 2)));
    737         assertTrue(badPatches.contains(new Point(1, 3)));
    738         assertTrue(badPatches.contains(new Point(1, 4)));
    739         assertTrue(badPatches.contains(new Point(1, 5)));
    740 
    741         assertTrue(badPatches.contains(new Point(2, 1)));
    742         assertTrue(badPatches.contains(new Point(2, 5)));
    743 
    744         assertTrue(badPatches.contains(new Point(3, 0)));
    745         assertTrue(badPatches.contains(new Point(3, 1)));
    746         assertTrue(badPatches.contains(new Point(3, 5)));
    747         assertTrue(badPatches.contains(new Point(3, 6)));
    748 
    749         assertTrue(badPatches.contains(new Point(4, 1)));
    750         assertTrue(badPatches.contains(new Point(4, 3)));
    751         assertTrue(badPatches.contains(new Point(4, 5)));
    752     }
    753 
    754     public void testProjection() throws Exception {
    755         // top
    756         String fileName = DIR + "patched3.9.png";
    757         NinePatchedImage image = new NinePatchedImage(getClass()
    758                 .getResourceAsStream(fileName), fileName);
    759         assertNotNull(image);
    760 
    761         assertTrue(image.hasNinePatchExtension());
    762         assertTrue(image.ensure9Patch());
    763 
    764         ImageData data = image.getImageData();
    765         assertEquals(72 + 2, data.width);
    766         assertEquals(50 + 2, data.height);
    767 
    768         int width = 72 * 2;
    769         int height = 50 * 2;
    770 
    771         Chunk[][] chunks = null;
    772         chunks = image.getChunks(chunks);
    773 
    774         Projection[][] projections = null;
    775         projections = image.getProjections(width, height, projections);
    776 
    777         assertEquals(chunks.length, projections.length);
    778         for (int i = 0; i < chunks.length; i++) {
    779             assertEquals(chunks[i].length, projections[i].length);
    780         }
    781 
    782         for (int y = 0; y < projections.length; y++) {
    783             for (int x = 0; x < projections[y].length; x++) {
    784                 assertEquals(projections[y][x].src, chunks[y][x].rect);
    785 
    786                 // If chunk type is FIXED. Same projection size as original
    787                 // chunk.
    788                 if (projections[y][x].chunk.type == Chunk.TYPE_FIXED) {
    789                     assertEquals(projections[y][x].dest.width, chunks[y][x].rect.width);
    790                     assertEquals(projections[y][x].dest.height, chunks[y][x].rect.height);
    791                 }
    792             }
    793         }
    794 
    795         Projection p = null;
    796         Rectangle rect = null;
    797 
    798         // Check start position
    799         p = projections[0][0];
    800 
    801         // src position start from 1, 9-patch row and column included.
    802         assertEquals(1, p.src.x);
    803         assertEquals(1, p.src.y);
    804 
    805         // dest position start from 0, 9-patch row and column ignored.
    806         assertEquals(0, p.dest.x);
    807         assertEquals(0, p.dest.y);
    808 
    809         // row 1
    810         p = projections[0][0];
    811         rect = p.dest;
    812         assertEquals(0, rect.x);
    813         assertEquals(0, rect.y);
    814         assertEquals(74, rect.width);
    815         assertEquals(5, rect.height);
    816 
    817         p = projections[0][1];
    818         rect = p.dest;
    819         assertEquals(74, rect.x);
    820         assertEquals(0, rect.y);
    821         assertEquals(62, rect.width);
    822         assertEquals(5, rect.height);
    823 
    824         p = projections[0][2];
    825         rect = p.dest;
    826         assertEquals(136, rect.x);
    827         assertEquals(0, rect.y);
    828         assertEquals(8, rect.width);
    829         assertEquals(5, rect.height);
    830 
    831         // row 2
    832         p = projections[1][0];
    833         rect = p.dest;
    834         assertEquals(0, rect.x);
    835         assertEquals(5, rect.y);
    836         assertEquals(74, rect.width);
    837         assertEquals(24, rect.height);
    838 
    839         p = projections[1][1];
    840         rect = p.dest;
    841         assertEquals(74, rect.x);
    842         assertEquals(5, rect.y);
    843         assertEquals(62, rect.width);
    844         assertEquals(24, rect.height);
    845 
    846         p = projections[1][2];
    847         rect = p.dest;
    848         assertEquals(136, rect.x);
    849         assertEquals(5, rect.y);
    850         assertEquals(8, rect.width);
    851         assertEquals(24, rect.height);
    852 
    853         // row 3
    854         p = projections[2][0];
    855         rect = p.dest;
    856         assertEquals(0, rect.x);
    857         assertEquals(29, rect.y);
    858         assertEquals(74, rect.width);
    859         assertEquals(58, rect.height);
    860 
    861         p = projections[2][1];
    862         rect = p.dest;
    863         assertEquals(74, rect.x);
    864         assertEquals(29, rect.y);
    865         assertEquals(62, rect.width);
    866         assertEquals(58, rect.height);
    867 
    868         p = projections[2][2];
    869         rect = p.dest;
    870         assertEquals(136, rect.x);
    871         assertEquals(29, rect.y);
    872         assertEquals(8, rect.width);
    873         assertEquals(58, rect.height);
    874 
    875         // row 4
    876         p = projections[3][0];
    877         rect = p.dest;
    878         assertEquals(0, rect.x);
    879         assertEquals(87, rect.y);
    880         assertEquals(74, rect.width);
    881         assertEquals(13, rect.height);
    882 
    883         p = projections[3][1];
    884         rect = p.dest;
    885         assertEquals(74, rect.x);
    886         assertEquals(87, rect.y);
    887         assertEquals(62, rect.width);
    888         assertEquals(13, rect.height);
    889 
    890         p = projections[3][2];
    891         rect = p.dest;
    892         assertEquals(136, rect.x);
    893         assertEquals(87, rect.y);
    894         assertEquals(8, rect.width);
    895         assertEquals(13, rect.height);
    896     }
    897 
    898     public void testReadLayoutBoundsOnlyImage() throws Exception {
    899         String fileName = DIR + "layout-bounds-only.9.png";
    900         NinePatchedImage image = new NinePatchedImage(getClass()
    901                 .getResourceAsStream(fileName), fileName);
    902         assertNotNull(image);
    903 
    904         ImageData data = image.getImageData();
    905         int width = data.width;
    906         int height = data.height;
    907 
    908         assertEquals(74, width);
    909         assertEquals(52, height);
    910 
    911         assertTrue(image.hasNinePatchExtension());
    912         assertTrue(image.ensure9Patch());
    913     }
    914 }
    915