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